def predict_main(aoi_path): """this functions trakes as input the json file fr4om frontend and returns the subpolygones with co2 metrcis aoi: json file with area of intreste from frontend """ # download images from gee data_parent_path = os.path.join("..", "data", "raw") dataset_name = data.download_dataset(aoi_path, data_parent_path=data_parent_path, get_sent2=True, get_glc=False, get_ndvi=False) # preprocess data (creates dataset folder structure in data/preprocessed # from data import make_dataset data.make_dataset(dataset_name) # predict land cover prediction = predict_model(dataset_name) # prediction is a json with subpolygones # get co2 estimations prediction = calc_vegetation_co_metric( prediction) # adds attribute "veg_co2_metric" to predictions prediction = calc_soil_co_metric( prediction) # adds attribute "soil_co2_metric" to predictions #return prediction pass
def main(argv): """Builds, trains, and evaluates the model.""" args = parser.parse_args(argv[1:]) (train_x, train_y), (test_x, test_y) = data.load_data() # Provide the training input dataset. train_input_fn = data.make_dataset(args.batch_size, train_x, train_y, True, 1000) # Provide the validation input dataset. test_input_fn = data.make_dataset(args.batch_size, test_x, test_y) # Use the same categorical columns as in `linear_regression_categorical` body_style_vocab = ["47980dda", "79ceee49"] body_style_column = tf.feature_column.categorical_column_with_vocabulary_list( key="auction_boolean_0", vocabulary_list=body_style_vocab) #make_column = tf.feature_column.categorical_column_with_hash_bucket( #key="make", hash_bucket_size=50) feature_columns = [ tf.feature_column.numeric_column(key="creative_height"), tf.feature_column.numeric_column(key="creative_width"), # Since this is a DNN model, categorical columns must be converted from # sparse to dense. # Wrap them in an `indicator_column` to create a # one-hot vector from the input. tf.feature_column.indicator_column(body_style_column) # Or use an `embedding_column` to create a trainable vector for each # index. #tf.feature_column.embedding_column(make_column, dimension=3), ] # Build a DNNRegressor, with 2x20-unit hidden layers, with the feature columns # defined above as input. model = tf.estimator.LinearClassifier(feature_columns=feature_columns, n_classes=2) # Train the model. # By default, the Estimators log output every 100 steps. model.train(input_fn=train_input_fn, steps=args.train_steps) # Evaluate how the model performs on data it has not yet seen. eval_result = model.evaluate(input_fn=test_input_fn) # The evaluation returns a Python dictionary. The "average_loss" key holds the # Mean Squared Error (MSE). average_loss = eval_result["average_loss"] # Convert MSE to Root Mean Square Error (RMSE). print("\n" + 80 * "*") print("\nRMS error for the test set: ${:.0f}".format(average_loss)) print()
def train_input_fn(): return data.make_dataset(config['train_images'], config['img_feature_name'], config['img_size'], config['num_channels'], batch_size=config['batch_size'], num_epochs=config['epochs_per_eval'], shuffle=True)
def test_input_fn(): return data.make_dataset(config['test_images'], config['img_feature_name'], config['img_size'], config['num_channels'], batch_size=config['batch_size'], grayscale=config['grayscale'], shuffle=False)
def make_model(in_path, out_path, n_epochs=500, gen_type="balanced"): (X_train, y_train), test = data.make_dataset(in_path, False) gen = sim.gen.get_data_generator(gen_type) X, y = gen(X_train, y_train) X, n_cats, n_channels = prepare_data(X, y) # raise Exception(n_cats) sim_metric, model = make_five(n_cats, n_channels, params=None) sim_metric.fit(X, y, epochs=n_epochs, batch_size=128) if (out_path): model.save(out_path)
def show_frames(in_path, out_path): (X_train, y_train), test = data.make_dataset(in_path, False) X, y = sim.gen.OneCat(14)(X_train, y_train) #balanced_data(X_train,y_train) files.make_dir(out_path) for i, y_i in enumerate(y): x0, x1 = X[0][i], X[1][i] cat_i = np.argmax(y_i) img_i = np.concatenate([x0, x1]) out_i = '%s/%d_%d.png' % (out_path, i, cat_i) print(out_i) cv2.imwrite(out_i, img_i)
def simple_exp(in_path, out_path=None, n_epochs=500, model_type="old"): (X_train, y_train), (X_test, y_test) = data.make_dataset(in_path) n_cats, n_channels = data.get_params(X_train, y_train) X_train, y_train = prepare_data(X_train, y_train, n_channels) X_test, y_test = prepare_data(X_test, y_test, n_channels) model_factory, params = models.get_model_factory(model_type) model = model_factory(n_cats, n_channels, params) model.summary() model.fit(X_train, y_train, epochs=n_epochs, batch_size=256) test_model(X_test, y_test, model) if (out_path): model.save(out_path)
def train_binary_model(in_path,out_path,n_epochs=150,model_type='exp'): (X_train,y_train),(X_test,y_test)=data.make_dataset(in_path) n_cats,n_channels=data.get_params(X_train,y_train) X_train,y_train=basic.prepare_data(X_train,y_train,n_channels) X_test,y_test=basic.prepare_data(X_test,y_test,n_channels) model_factory,params=models.get_model_factory(model_type) files.make_dir(out_path) for cat_i in range(n_cats): y_i=binarize(y_train,cat_i) model=model_factory(2,n_channels,params) model.summary() model.fit(X_train,y_i,epochs=n_epochs,batch_size=256) out_i=out_path+'/nn'+str(cat_i) model.save(out_i)
def main(): parser = ArgumentParser() parser.add_argument('--data-dir', help='Location where TFRecord files are') parser.add_argument('--model-dir', help='Location where model will be saved') parser.add_argument('--max-steps', default=10000) args, _ = parser.parse_known_args() # Ensure our model directory exists tf.gfile.MakeDirs(args.model_dir) config = tf.estimator.RunConfig( train_distribute=tf.contrib.distribute.MirroredStrategy()) estimator = tf.estimator.Estimator(model_fn=model.unet_model, model_dir=args.model_dir, config=config, params={'learning_rate': 1e-4}) tf.logging.set_verbosity(tf.logging.INFO) train_input_fn = lambda: data.make_dataset(os.path.join( args.data_dir, 'train-*.tfrecord'), batch_size=2, shuffle=True) train_spec = tf.estimator.TrainSpec( train_input_fn, max_steps=args.max_steps) #, hooks=[debug_hook]) val_input_fn = lambda: data.make_dataset(os.path.join( args.data_dir, 'validation-0.tfrecord'), batch_size=2, shuffle=False) eval_spec = tf.estimator.EvalSpec(val_input_fn, steps=20) tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
def train(in_path, out_path=None, n_epochs=1000, recon=True): (X_train, y_train), (X_test, y_test) = data.make_dataset(in_path) n_cats, n_channels = data.get_params(X_train, y_train) X = data.format_frames(X_train, n_channels) noise_X = add_noise(X) make_model, params = models.auto.get_model_factory("basic") model, recon = make_model(n_channels, params) recon.summary() gc.collect() recon.fit(noise_X, X, epochs=n_epochs, batch_size=256) #, # shuffle=True,validation_data=(X, X)) if (not out_path): dest_dir = os.path.split(in_path)[0] out_path = dest_dir + '/ae' model.save(out_path) if (recon): recon.save(out_path + "_recon")
def train(args): tf.enable_eager_execution() tf.executing_eagerly() tfe = tf.contrib.eager writer = tf.contrib.summary.create_file_writer("./log") global_step = tf.train.get_or_create_global_step() writer.set_as_default() dataset = make_dataset("./train.csv", args.batch_size, args.n_class) model = MultiSegCaps(n_class=args.n_class) #optimizer = tf.train.AdamOptimizer(learning_rate=args.lr) optimizer = tf.train.GradientDescentOptimizer(learning_rate=args.lr) checkpoint_dir = './models' checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt") root = tfe.Checkpoint(optimizer=optimizer, model=model, optimizer_step=tf.train.get_or_create_global_step()) with tf.contrib.summary.record_summaries_every_n_global_steps(50): for epoch in range(args.epoch): for imgs, lbls in dataset: global_step.assign_add(1) with tf.GradientTape() as tape: out_seg, reconstruct = model(imgs, lbls) segmentation_loss = tf.losses.softmax_cross_entropy( lbls, out_seg) tf.contrib.summary.scalar('segmentation_loss', segmentation_loss) #segmetation_loss = weighted_margin_loss(out_seg, lbls, class_weighting=[0,1,1,1,1]) reconstruct_loss = reconstruction_loss(reconstruct, imgs, rs=args.rs) tf.contrib.summary.scalar('reconstruction_loss', reconstruct_loss) total_loss = segmentation_loss + reconstruct_loss tf.contrib.summary.scalar('total_loss', total_loss) print(total_loss) grad = tape.gradient(total_loss, model.variables) optimizer.apply_gradients( zip(grad, model.variables), global_step=tf.train.get_or_create_global_step()) if epoch % 10 == 0: root.save(file_prefix=checkpoint_prefix)
def main(args): os.environ['CUDA_VISIBLE_DEVICES'] = args.device sess = tf.Session() model = VGG19(nb_classes=2, is_training=False) img_height, img_width, _ = model.SHAPE saver = tf.train.Saver() saver.restore(sess, args.checkpoint) columns = ['filename', 'attack', 'iteration', 'label', 'class_0_pred', 'class_1_pred', 'l2_norm'] data = [] def preprocess_func(x, y): x = read_image(x) x = decode_png(x) x = resize(x, img_height, img_width) return x, y allowed_attacks = set([a.strip() for a in args.attacks.split(',') if len(a.strip()) > 0]) for attack_dir in os.listdir(args.data): if not attack_dir in allowed_attacks: continue logger.debug("Start processing attack {}".format(attack_dir)) for iter_dir in os.listdir(join(args.data, attack_dir)): logger.debug("Start processing iteration #{}".format(int(iter_dir))) source_dir = join(args.data, attack_dir, iter_dir) dataset = make_dataset(source_dir, 128, preprocess_func, shuffle=False, repeat=False) iter_data = fetch_data(sess, model, dataset, attack_dir, iter_dir) data.extend(iter_data) dataframe = pd.DataFrame(data=data, columns=columns) dataframe.to_csv(args.csv, index=False)
shutil.copy2(args.config, output_dir) # logger logger = make_logger("project", opt.output_dir, 'log') # device if opt.device == 'cuda': os.environ['CUDA_VISIBLE_DEVICES'] = opt.device_id num_gpus = len(opt.device_id.split(',')) logger.info("Using {} GPUs.".format(num_gpus)) logger.info("Training on {}.\n".format(torch.cuda.get_device_name(0))) cudnn.benchmark = True device = torch.device(opt.device) # create the dataset for training dataset = make_dataset(opt.dataset) # init the network style_gan = StyleGAN(structure=opt.structure, resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, latent_size=opt.model.gen.latent_size, g_args=opt.model.gen, d_args=opt.model.dis, g_opt_args=opt.model.g_optim, d_opt_args=opt.model.d_optim, loss=opt.loss, drift=opt.drift, d_repeats=opt.d_repeats, use_ema=opt.use_ema, ema_decay=opt.ema_decay,
import tensorflow as tf from data import make_dataset import time import matplotlib.pyplot as plt ''' Implementation of k-means ++ ''' tf.config.threading.set_inter_op_parallelism_threads(8) tf.config.threading.set_intra_op_parallelism_threads(8) NUM_CLUSTER = 9 NUM_ITERS = 30 NEW_CENTRIOD_THRESHOLD = 0.98 ds_1 = make_dataset(BATCH_SIZE=1, file_name='train_tf_record', split=False) ds_2 = make_dataset(BATCH_SIZE=1, file_name='test_tf_record', split=False) ds = ds_1.concatenate(ds_2) NUM_SAMPLES = len(list(ds)) frame = [] for sample in ds: for num, x_min in enumerate(sample[1]): y_min = sample[2][num] x_max = sample[3][num] y_max = sample[4][num] width = tf.cast((x_max - x_min), tf.float32).numpy() height = tf.cast((y_max - y_min), tf.float32).numpy() frame.append((width, height)) # Calculate initial centroids (K-Means++)
def train(config, anchors): num_epoch = int(config.epoch) log_dir = './results/' # Load dataset path = os.getcwd() train_file = path + '/train_tf_record' test_file = path + '/test_tf_record' train_dataset, val_dataset = make_dataset( BATCH_SIZE=config.training_batch_size, file_name=train_file, split=True) test_dataset = make_dataset(BATCH_SIZE=config.test_batch_size, file_name=test_file, split=False) # Model model = load_model(1, anchors, config.model_size, load_full_weights=config.load_full_weights) # set optimizer optimizer = tf.keras.optimizers.Adam(learning_rate=config.lr) # set Metrics tr_sum_loss = tf.keras.metrics.Mean() tr_iou = tf.keras.metrics.Mean() val_xy_loss = tf.keras.metrics.Mean() val_wh_loss = tf.keras.metrics.Mean() val_obj_loss = tf.keras.metrics.Mean() val_prob_loss = tf.keras.metrics.Mean() val_sum_loss = tf.keras.metrics.Mean() val_iou = tf.keras.metrics.Mean() test_iou = tf.keras.metrics.Mean() # Save Checkpoint ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=optimizer, net=model) manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=5) # Set up summary writers current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") tb_log_dir = log_dir + current_time summary_writer = tf.summary.create_file_writer(tb_log_dir) # Restore Checkpoint ckpt.restore(manager.latest_checkpoint) if manager.latest_checkpoint: logging.info('Restored from {}'.format(manager.latest_checkpoint)) else: logging.info('Initializing from scratch.') # calculate losses, update network and metrics. @tf.function def train_step(images, y_true): # Optimize the model with tf.GradientTape() as tape: detect0, detect1, detect2 = model(images, training=True, finetuning=config.finetuning) de_de0 = decode(detect0, anchors[2], 1, config.model_size) de_de1 = decode(detect1, anchors[1], 1, config.model_size) de_de2 = decode(detect2, anchors[0], 1, config.model_size) loss_de0 = yolo_loss(detect0, y_true, de_de0, anchors[2], config.model_size) loss_de1 = yolo_loss(detect1, y_true, de_de1, anchors[1], config.model_size) loss_de2 = yolo_loss(detect2, y_true, de_de2, anchors[0], config.model_size) total_loss = loss_de0 + loss_de1 + loss_de2 sum_loss = tf.reduce_sum(total_loss) grads = tape.gradient(sum_loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) x = tf.concat([de_de0, de_de1, de_de2], axis=1) x = build_boxes(x) boxes_dicts = non_max_suppression(x, model.n_classes, config.max_out_size, config.iou_threshold, config.confid_threshold) return sum_loss, boxes_dicts @tf.function def val_step(images, y_true): detect0, detect1, detect2 = model(images, training=False) de_de0 = decode(detect0, anchors[2], 1, config.model_size) de_de1 = decode(detect1, anchors[1], 1, config.model_size) de_de2 = decode(detect2, anchors[0], 1, config.model_size) loss_de0 = yolo_loss(detect0, y_true, de_de0, anchors[2], config.model_size) loss_de1 = yolo_loss(detect1, y_true, de_de1, anchors[1], config.model_size) loss_de2 = yolo_loss(detect2, y_true, de_de2, anchors[0], config.model_size) total_loss = loss_de0 + loss_de1 + loss_de2 x = tf.concat([de_de0, de_de1, de_de2], axis=1) x = build_boxes(x) boxes_dicts = non_max_suppression(x, model.n_classes, config.max_out_size, config.iou_threshold, config.confid_threshold) return total_loss, boxes_dicts @tf.function def test_step(images): detect0, detect1, detect2 = model(images, training=False) de_de0 = decode(detect0, anchors[2], 1, config.model_size) de_de1 = decode(detect0, anchors[1], 1, config.model_size) de_de2 = decode(detect0, anchors[0], 1, config.model_size) x = tf.concat([de_de0, de_de1, de_de2], axis=1) x = build_boxes(x) boxes_dicts = non_max_suppression(x, model.n_classes, config.max_out_size, config.iou_threshold, config.confid_threshold) return boxes_dicts for epoch in range(num_epoch): begin = time.time() # Training loop for i in train_dataset: images = data_augmentation(i[0], config.probability, config.brightness_delta, config.contrast_range, config.hue_delta) y_true = i[1:] sum_loss, boxes_dicts = train_step(images, y_true) tr_sum_loss.update_state(sum_loss) pred_points = list(map(lambda x: x[0][..., 0:4], boxes_dicts)) pred_points = tf.concat(pred_points, axis=0) for _ in range(config.training_batch_size - tf.shape(pred_points)[0]): pred_points = tf.concat( values=[pred_points, tf.constant([[0., 0., 0., 0.]])], axis=0) training_iou_batch = tf.reduce_mean( iou(pred_points, tf.cast(tf.stack(y_true[0:4], axis=-1), dtype=tf.float32))) tr_iou.update_state(training_iou_batch) for j in val_dataset: images = j[0] y_true = j[1:] total_loss, boxes_dicts = val_step(images, y_true) val_xy_loss.update_state(total_loss[0]) val_wh_loss.update_state(total_loss[1]) val_obj_loss.update_state(total_loss[2]) val_prob_loss.update_state(total_loss[3]) val_sum_loss.update_state(tf.reduce_sum(total_loss)) pred_points = list(map(lambda x: x[0][..., 0:4], boxes_dicts)) pred_points = tf.concat(pred_points, axis=0) for _ in range(config.training_batch_size - tf.shape(pred_points)[0]): pred_points = tf.concat( values=[pred_points, tf.constant([[0., 0., 0., 0.]])], axis=0) val_iou_batch = tf.reduce_mean( iou(pred_points, tf.cast(tf.stack(y_true[0:4], axis=-1), dtype=tf.float32))) val_iou.update_state(val_iou_batch) with summary_writer.as_default(): tf.summary.scalar('Train Sum loss', tr_sum_loss.result(), step=epoch) tf.summary.scalar('Train IOU', tr_iou.result(), step=epoch) tf.summary.scalar('Validation XY loss', val_xy_loss.result(), step=epoch) tf.summary.scalar('Validation WH loss', val_wh_loss.result(), step=epoch) tf.summary.scalar('Validation OBJ loss', val_obj_loss.result(), step=epoch) tf.summary.scalar('Validation PROB loss', val_prob_loss.result(), step=epoch) tf.summary.scalar('Validation Sum loss', val_sum_loss.result(), step=epoch) tf.summary.scalar('Validation IOU', val_iou.result(), step=epoch) end = time.time() logging.info( "Epoch {:d} Training Sum loss: {:.3}, Training IOU: {:.3%} \n Validation Sum loss: {:.3}, " "Validation IOU: {:.3%}, Time:{:.5}s".format( epoch + 1, tr_sum_loss.result(), tr_iou.result(), val_sum_loss.result(), val_iou.result(), (end - begin))) tr_sum_loss.reset_states() tr_iou.reset_states() val_xy_loss.reset_states() val_wh_loss.reset_states() val_obj_loss.reset_states() val_prob_loss.reset_states() val_sum_loss.reset_states() val_iou.reset_states() if int(ckpt.step) % 5 == 0: save_path = manager.save() logging.info('Saved checkpoint for epoch {}: {}'.format( int(ckpt.step), save_path)) ckpt.step.assign_add(1) if epoch % 1 == 0: for j in test_dataset: images = j[0] y_true = j[1:] boxes_dicts = test_step(images) pred_points = list(map(lambda x: x[0][..., 0:4], boxes_dicts)) pred_points = tf.concat(pred_points, axis=0) for _ in range(config.test_batch_size - tf.shape(pred_points)[0]): pred_points = tf.concat( values=[pred_points, tf.constant([[0., 0., 0., 0.]])], axis=0) test_iou_batch = tf.reduce_mean( iou( pred_points, tf.cast(tf.stack(y_true[0:4], axis=-1), dtype=tf.float32))) test_iou.update_state(test_iou_batch) # test image visualization time_begin = time.time() test_sample = next(iter(test_dataset)) images = test_sample[0][0] y_true = list(map(lambda x: x[0], test_sample[1:])) # numpy array is necessary for openCV images_tf = tf.expand_dims(images, axis=0) images = tf.cast(images * 255, tf.uint8).numpy() images = cv.cvtColor(images, cv.COLOR_BGR2RGB) box_dicts = test_step(images_tf) draw_boxes_cv2(images, box_dicts, [y_true[4].numpy().decode('utf-8')], config.model_size, time_begin) cv.rectangle(images, (y_true[0], y_true[1]), (y_true[2], y_true[3]), (0, 0, 255), 2) images = cv.cvtColor(images, cv.COLOR_RGB2BGR) images = tf.expand_dims(images, axis=0) with summary_writer.as_default(): tf.summary.image('Test Object detection', images, step=epoch) tf.summary.scalar('Test IOU', test_iou.result(), step=epoch) logging.info("Test IOU: {:.3%}".format(test_iou.result())) test_iou.reset_states()
os.mkdir(save_dir) ckpt_dir = './info_output/%s/checkpoints/' % experiment_name if not os.path.exists(ckpt_dir): os.mkdir(ckpt_dir) train_hist = {} train_hist['D_loss'] = [] train_hist['G_loss'] = [] train_hist['info_loss'] = [] train_hist['per_epoch_time'] = [] train_hist['total_time'] = [] #dataSets data_loader, shape = data.make_dataset(dataset_name='celebaHQ', batch_size=batch_size, img_size=img_size, pin_memory=True) #---------------- Pre-Model ------------ #-----DCGAN celebaA---------## input_dim=256, Gscale=8, Dscale=4 import network.network_1 as net1 import network.network_1_SSencoder as net2 def toggle_grad(model, requires_grad): for p in model.parameters(): p.requires_grad_(requires_grad) netG1 = net1.Generator(
print("knn_cls result : ", knn_cls) ret_dict['knn_cls'] = knn_cls X_sub, Y_sub = sub_select_knn_anneal(X, Y, n_sub) knn_anneal = get_acc(clf, X_sub, Y_sub, X_t, Y_t) print("knn_anneal result : ", knn_anneal) ret_dict['knn_anneal'] = knn_anneal return ret_dict if __name__ == "__main__": n = 2000 n_tr = n // 2 X, Y = make_dataset(n) X_tr, Y_tr = X[:n_tr], Y[:n_tr] X_t, Y_t = X[n_tr:], Y[n_tr:] # some TSNE print for all features and only class relevant features tsne(X_tr, Y_tr, "all_feature") X_emb = [get_class(x) for x in X] tsne(X_emb, Y, "class_feature") X_style = [get_style(x) for x in X] tsne(X_style, Y, "style_feature") X_common = [get_common(x) for x in X] tsne(X_common, Y, "common_feature") clf_name = 'knn' sub_sizes = [10 * i for i in range(1, 21)]
def eval_input_fn(): return data.make_dataset(config['val_images'], config['img_feature_name'], config['img_size'], config['num_channels'], shuffle=False)
test_dataset = test_dataset.padded_batch(config.batch_size, padded_shapes=([None], [])) model = tf.keras.Sequential([ tf.keras.layers.Embedding(config.vocab_size, config.embedding_dim), tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(config.rnn_units)), tf.keras.layers.Dense(config.rnn_units, activation='relu'), tf.keras.layers.Dense(1) ]) model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), optimizer=tf.keras.optimizers.Adam(1e-4), metrics=['accuracy']) checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt_{epoch}") checkpoint_callback = tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_prefix, save_weights_only=True) history = model.fit(train_dataset, epochs=config.epochs, validation_data=test_dataset, validation_steps=config.validation_steps, callbacks=[checkpoint_callback]) if __name__ == "__main__": config = TrainConfig dataset, encoder = make_dataset('train.txt', ['name', 'gender'], 'gender') config.vocab_size = encoder.vocab_size train(dataset, './training_checkpoints', config)
def train(hparams, num_epoch, tuning): log_dir = './results/' test_batch_size = 8 # Load dataset training_set, valid_set = make_dataset(BATCH_SIZE=hparams['HP_BS'], file_name='train_tf_record', split=True) test_set = make_dataset(BATCH_SIZE=test_batch_size, file_name='test_tf_record', split=False) class_names = ['NRDR', 'RDR'] # Model model = ResNet() # set optimizer optimizer = tf.keras.optimizers.Adam(learning_rate=hparams['HP_LR']) # set metrics train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy() valid_accuracy = tf.keras.metrics.Accuracy() valid_con_mat = ConfusionMatrix(num_class=2) test_accuracy = tf.keras.metrics.Accuracy() test_con_mat = ConfusionMatrix(num_class=2) # Save Checkpoint if not tuning: ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=optimizer, net=model) manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=5) # Set up summary writers current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") tb_log_dir = log_dir + current_time + '/train' summary_writer = tf.summary.create_file_writer(tb_log_dir) # Restore Checkpoint if not tuning: ckpt.restore(manager.latest_checkpoint) if manager.latest_checkpoint: logging.info('Restored from {}'.format(manager.latest_checkpoint)) else: logging.info('Initializing from scratch.') @tf.function def train_step(train_img, train_label): # Optimize the model loss_value, grads = grad(model, train_img, train_label) optimizer.apply_gradients(zip(grads, model.trainable_variables)) train_pred, _ = model(train_img) train_label = tf.expand_dims(train_label, axis=1) train_accuracy.update_state(train_label, train_pred) for epoch in range(num_epoch): begin = time() # Training loop for train_img, train_label, train_name in training_set: train_img = data_augmentation(train_img) train_step(train_img, train_label) with summary_writer.as_default(): tf.summary.scalar('Train Accuracy', train_accuracy.result(), step=epoch) for valid_img, valid_label, _ in valid_set: valid_img = tf.cast(valid_img, tf.float32) valid_img = valid_img / 255.0 valid_pred, _ = model(valid_img, training=False) valid_pred = tf.cast(tf.argmax(valid_pred, axis=1), dtype=tf.int64) valid_con_mat.update_state(valid_label, valid_pred) valid_accuracy.update_state(valid_label, valid_pred) # Log the confusion matrix as an image summary cm_valid = valid_con_mat.result() figure = plot_confusion_matrix(cm_valid, class_names=class_names) cm_valid_image = plot_to_image(figure) with summary_writer.as_default(): tf.summary.scalar('Valid Accuracy', valid_accuracy.result(), step=epoch) tf.summary.image('Valid ConfusionMatrix', cm_valid_image, step=epoch) end = time() logging.info( "Epoch {:d} Training Accuracy: {:.3%} Validation Accuracy: {:.3%} Time:{:.5}s" .format(epoch + 1, train_accuracy.result(), valid_accuracy.result(), (end - begin))) train_accuracy.reset_states() valid_accuracy.reset_states() valid_con_mat.reset_states() if not tuning: if int(ckpt.step) % 5 == 0: save_path = manager.save() logging.info('Saved checkpoint for epoch {}: {}'.format( int(ckpt.step), save_path)) ckpt.step.assign_add(1) for test_img, test_label, _ in test_set: test_img = tf.cast(test_img, tf.float32) test_img = test_img / 255.0 test_pred, _ = model(test_img, training=False) test_pred = tf.cast(tf.argmax(test_pred, axis=1), dtype=tf.int64) test_accuracy.update_state(test_label, test_pred) test_con_mat.update_state(test_label, test_pred) cm_test = test_con_mat.result() # Log the confusion matrix as an image summary figure = plot_confusion_matrix(cm_test, class_names=class_names) cm_test_image = plot_to_image(figure) with summary_writer.as_default(): tf.summary.scalar('Test Accuracy', test_accuracy.result(), step=epoch) tf.summary.image('Test ConfusionMatrix', cm_test_image, step=epoch) logging.info("Trained finished. Final Accuracy in test set: {:.3%}".format( test_accuracy.result())) # Visualization if not tuning: for vis_img, vis_label, vis_name in test_set: vis_label = vis_label[0] vis_name = vis_name[0] vis_img = tf.cast(vis_img[0], tf.float32) vis_img = tf.expand_dims(vis_img, axis=0) vis_img = vis_img / 255.0 with tf.GradientTape() as tape: vis_pred, conv_output = model(vis_img, training=False) pred_label = tf.argmax(vis_pred, axis=-1) vis_pred = tf.reduce_max(vis_pred, axis=-1) grad_1 = tape.gradient(vis_pred, conv_output) weight = tf.reduce_mean(grad_1, axis=[1, 2]) / grad_1.shape[1] act_map0 = tf.nn.relu( tf.reduce_sum(weight * conv_output, axis=-1)) act_map0 = tf.squeeze(tf.image.resize(tf.expand_dims(act_map0, axis=-1), (256, 256), antialias=True), axis=-1) plot_map(vis_img, act_map0, vis_pred, pred_label, vis_label, vis_name) break return test_accuracy.result()
def main(): device = '/gpu:0' if not FLAGS.no_gpu else '/cpu:0' full_dataset, tokenizer, size = data.make_dataset(FLAGS.dataset_name, FLAGS.dataset_type, FLAGS.data_dir, FLAGS.seq_length) # Dataset processing train_dataset, valid_dataset, test_dataset = _split( full_dataset, FLAGS.train_frac, FLAGS.valid_frac, FLAGS.test_frac, size) train_dataset = (train_dataset.batch( FLAGS.batch_size, drop_remainder=True).prefetch(2 * FLAGS.batch_size)) valid_dataset = (valid_dataset.batch( FLAGS.batch_size, drop_remainder=True).prefetch(2 * FLAGS.batch_size)) test_dataset = (test_dataset.batch( FLAGS.batch_size, drop_remainder=True).prefetch(2 * FLAGS.batch_size)) logging.info('Loaded dataset {}_{} with shape {}'.format( FLAGS.dataset_name, FLAGS.dataset_type, train_dataset.output_shapes)) logging.info('Dataset size {}'.format(size)) for x, y in train_dataset.take(1): logging.info('x:{} ; y:{}'.format(x.numpy(), y.numpy())) if FLAGS.pretrain: lm = LanguageModelRNN(tokenizer.vocab_size, FLAGS.embed_dim, FLAGS.RNN_sizes[0], (not FLAGS.no_mask), False) latest_ckpt = tf.train.latest_checkpoint(FLAGS.pretrain_lm_dir) lm_ckpt = tf.train.Checkpoint(model=lm) lm_ckpt.restore(latest_ckpt) if FLAGS.model == 'LanguageModelRNN': model = LanguageModelRNN(tokenizer.vocab_size, FLAGS.embed_dim, FLAGS.RNN_sizes[0], (not FLAGS.no_mask), False) elif FLAGS.model == 'UniRNN': model = UniRNN(tokenizer.vocab_size, FLAGS.embed_dim, FLAGS.RNN_sizes[0], 2, (not FLAGS.no_mask), False) else: raise NotImplementedError # Create optimizer optimizer = tf.train.AdamOptimizer(FLAGS.lr) # Initialize summaries and checkpointing summary_writer = tf.contrib.summary.create_file_writer(FLAGS.log_dir, flush_millis=1000) checkpoint_prefix = os.path.join(FLAGS.checkpoint_dir, 'ckpt') latest_ckpt = tf.train.latest_checkpoint(FLAGS.checkpoint_dir) if latest_ckpt: print('Using latest checkpoint at ' + latest_ckpt) checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model) checkpoint.restore(latest_ckpt) # Create global TF ops global_step = tf.train.get_or_create_global_step() # Train loop if FLAGS.mode == 'train': with tf.device(device): for epoch in range(FLAGS.epochs): start = time.time() with summary_writer.as_default(): model.train(train_dataset, optimizer, global_step) val_loss = model.evaluate(valid_dataset) print(val_loss) end = time.time() checkpoint.save(checkpoint_prefix) logging.info( '\nTrain time for epoch #%d (step %d): %f seconds' % (checkpoint.save_counter.numpy(), global_step.numpy(), end - start)) elif FLAGS.mode == 'sample': seed_tokens = tokenizer.tokenize(FLAGS.sample_seed_text) seed = tf.constant(np.array(seed_tokens, dtype=np.int16)) seed = tf.expand_dims(seed, 0) print(seed.shape) inp = seed tokens = seed_tokens for i in range(FLAGS.sample_length): logits = model(inp) logits = tf.squeeze(logits, 0) logits = logits / FLAGS.temperature sample_tok = tf.multinomial(logits, num_samples=1)[-1, 0].numpy() tokens.append(sample_tok) inp = tf.expand_dims([sample_tok], 0) print(tokenizer.untokenize(tokens))
def main(): # Parse parser = model_utils.get_parser() FLAGS, unparsed = parser.parse_known_args() # Setup model_dir if FLAGS.model_name is None: model_name = "LanguageModel" else: model_name = FLAGS.model_name model_dir = os.path.abspath(FLAGS.base_dir) + '/{}/'.format(model_name) if not os.path.exists(model_dir): model_utils.setup_model_dir(model_dir, create_base=True) if FLAGS.no_restore: model_utils.remove_history(model_dir) model_utils.setup_model_dir(model_dir, create_base=False) # Start logging logger = model_utils.get_logger(model_name, model_dir) logger.info("Started constructing {}".format(model_name)) logger.info("Parsed args {}".format(FLAGS)) if FLAGS.no_restore: logger.info('Not restoring, deleted history.') # Get Dataset logger.info("Getting dataset {}".format(FLAGS.dataset_name)) full_dataset, tokenizer, size = data.make_dataset(FLAGS.dataset_name, FLAGS.dataset_type, FLAGS.data_dir, FLAGS.seq_length) # Create model hparams = create_hparams(FLAGS.hparams) lm = LanguageModel(tokenizer.vocab_size, hparams.embedding_dim, hparams.rnn_size, hparams.use_cudnn) optimizer = tf.train.AdamOptimizer(hparams.lr, hparams.beta1, hparams.beta2, hparams.epsilon) epoch_count = tf.Variable(1, 'epoch_count') global_step = tf.train.get_or_create_global_step() logger.info("Model created") # Create checkpointing checkpoint_dir = os.path.abspath(model_dir + 'ckpts/' + FLAGS.run_name) logger.info("Checkpoints at {}".format(checkpoint_dir)) checkpoint_prefix = checkpoint_dir + '/ckpt' checkpoint = tf.train.Checkpoint(optimizer=optimizer, lm=lm, epoch_count=epoch_count, global_step=global_step) if not FLAGS.no_restore: if not FLAGS.load_checkpoint is None: load_checkpoint = FLAGS.load_checkpoint else: load_checkpoint = tf.train.latest_checkpoint(checkpoint_dir) logger.info("Loading latest checkpoint...") logger.info("Loading checkpoint {}".format(load_checkpoint)) checkpoint.restore(load_checkpoint) # Create summary writer summary_dir = model_dir + 'log/' + FLAGS.run_name + '/' summary_writer = tf.contrib.summary.create_file_writer(summary_dir, flush_millis=1000) # Training if FLAGS.mode == "train": logger.info("Beginning training...") device = '/gpu:0' if not FLAGS.no_gpu else '/cpu:0' # Get training Dataset logger.info("Full dataset size: {}".format(int(size))) logger.info("Train dataset size: {}".format( int(size * FLAGS.use_frac * FLAGS.train_frac))) train_dataset, valid_dataset = model_utils.split( full_dataset, size, FLAGS.use_frac, FLAGS.train_frac) train_dataset = train_dataset.batch(FLAGS.batch_size, drop_remainder=True) valid_dataset = valid_dataset.batch(FLAGS.batch_size, drop_remainder=True) train_dataset = ( tf.data.experimental.prefetch_to_device(device)(train_dataset)) valid_dataset = ( tf.data.experimental.prefetch_to_device(device)(valid_dataset)) # Train loop train_losses = [] val_losses = [] patience_count = 0 for epoch in range(FLAGS.epochs): cur_epoch = epoch_count.numpy() + epoch logger.info("Starting epoch {}...".format(cur_epoch)) start = time.time() with summary_writer.as_default(): train_loss = lm.train(train_dataset, optimizer, global_step, FLAGS.log_interval) logger.info("Epoch {} complete: train loss = {:0.03f}".format( cur_epoch, train_loss)) logger.info("Validating...") val_loss = lm.evaluate(valid_dataset) logger.info("Validation loss = {:0.03f}".format(val_loss)) time_elapsed = time.time() - start logger.info("Took {:0.01f} seconds".format(time_elapsed)) # Checkpoint if FLAGS.early_stopping: if not val_losses or val_loss < min( val_losses) - FLAGS.es_delta: logger.info("Checkpointing...") checkpoint.save(checkpoint_prefix) elif patience_count + 1 > FLAGS.patience: logger.info("Early stopping reached") break else: patience_count += 1 else: logger.info("Checkpointing...") checkpoint.save(checkpoint_prefix) elif FLAGS.mode == "eval": logger.info("Beginning evaluation...") device = '/gpu:0' if not FLAGS.no_gpu else '/cpu:0' with summary_writer.as_default(): val_loss = lm.evaluate(full_dataset) logger.info("Validation loss: {:0.02f}".format(val_loss)) elif FLAGS.mode == "generate": # Generate samples logger.info("Generating samples...") for _ in range(FLAGS.num_samples): tokens = tokenizer.tokenize(FLAGS.seed_text) inp = tf.constant(np.array(tokens, dtype=np.int16)) inp = tf.expand_dims(inp, 0) _, state = lm.call_with_state(inp[:, 0:-1]) # Setup state cur_token = tokens[-1] done = False while not done: inp = tf.constant(np.array([cur_token], dtype=np.int16)) inp = tf.expand_dims(inp, 0) logits, state = lm.call_with_state(inp, state) logits = tf.squeeze(logits, 0) logits = logits / FLAGS.temperature cur_token = tf.multinomial(logits, num_samples=1)[-1, 0].numpy() tokens.append(cur_token) if len(tokens) > FLAGS.sample_length: done = True logger.info("{}".format(tokenizer.untokenize(tokens))) lm.recurrent.reset_states()
def create_graph(bound, state_size, num_timesteps, batch_size, num_samples, num_eval_samples, resampling_schedule, use_resampling_grads, learning_rate, lr_decay_steps, train_p, dtype='float64'): if FLAGS.use_bs: true_bs = None else: true_bs = [np.zeros([state_size]).astype(dtype) for _ in xrange(num_timesteps)] # Make the dataset. true_bs, dataset = data.make_dataset( bs=true_bs, state_size=state_size, num_timesteps=num_timesteps, batch_size=batch_size, num_samples=num_samples, variance=FLAGS.variance, prior_type=FLAGS.p_type, bimodal_prior_weight=FLAGS.bimodal_prior_weight, bimodal_prior_mean=FLAGS.bimodal_prior_mean, transition_type=FLAGS.transition_type, fixed_observation=FLAGS.fixed_observation, dtype=dtype) itr = dataset.make_one_shot_iterator() _, observations = itr.get_next() # Make the dataset for eval _, eval_dataset = data.make_dataset( bs=true_bs, state_size=state_size, num_timesteps=num_timesteps, batch_size=num_eval_samples, num_samples=num_eval_samples, variance=FLAGS.variance, prior_type=FLAGS.p_type, bimodal_prior_weight=FLAGS.bimodal_prior_weight, bimodal_prior_mean=FLAGS.bimodal_prior_mean, transition_type=FLAGS.transition_type, fixed_observation=FLAGS.fixed_observation, dtype=dtype) eval_itr = eval_dataset.make_one_shot_iterator() _, eval_observations = eval_itr.get_next() # Make the model. if bound == "fivo-aux-td": model = models.TDModel.create( state_size, num_timesteps, variance=FLAGS.variance, train_p=train_p, p_type=FLAGS.p_type, q_type=FLAGS.q_type, mixing_coeff=FLAGS.bimodal_prior_weight, prior_mode_mean=FLAGS.bimodal_prior_mean, observation_variance=FLAGS.observation_variance, transition_type=FLAGS.transition_type, use_bs=FLAGS.use_bs, dtype=tf.as_dtype(dtype), random_seed=FLAGS.random_seed) else: model = models.Model.create( state_size, num_timesteps, variance=FLAGS.variance, train_p=train_p, p_type=FLAGS.p_type, q_type=FLAGS.q_type, mixing_coeff=FLAGS.bimodal_prior_weight, prior_mode_mean=FLAGS.bimodal_prior_mean, observation_variance=FLAGS.observation_variance, transition_type=FLAGS.transition_type, use_bs=FLAGS.use_bs, r_sigma_init=FLAGS.r_sigma_init, dtype=tf.as_dtype(dtype), random_seed=FLAGS.random_seed) # Compute the bound and loss if bound == "iwae": (_, losses, ema_op, _, _) = bounds.iwae( model, observations, num_timesteps, num_samples=num_samples) (eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.iwae( model, eval_observations, num_timesteps, num_samples=num_eval_samples, summarize=True) eval_log_p_hat = tf.reduce_mean(eval_log_p_hat) elif "fivo" in bound: if bound == "fivo-aux-td": (_, losses, ema_op, _, _) = bounds.fivo_aux_td( model, observations, num_timesteps, resampling_schedule=resampling_schedule, num_samples=num_samples) (eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.fivo_aux_td( model, eval_observations, num_timesteps, resampling_schedule=resampling_schedule, num_samples=num_eval_samples, summarize=True) else: (_, losses, ema_op, _, _) = bounds.fivo( model, observations, num_timesteps, resampling_schedule=resampling_schedule, use_resampling_grads=use_resampling_grads, resampling_type=FLAGS.resampling_method, aux=("aux" in bound), num_samples=num_samples) (eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.fivo( model, eval_observations, num_timesteps, resampling_schedule=resampling_schedule, use_resampling_grads=False, resampling_type="multinomial", aux=("aux" in bound), num_samples=num_eval_samples, summarize=True) eval_log_p_hat = tf.reduce_mean(eval_log_p_hat) summ.summarize_ess(eval_log_weights, only_last_timestep=True) # if FLAGS.p_type == "bimodal": # # create the observations that showcase the model. # mode_odds_ratio = tf.convert_to_tensor([1., 3., 1./3., 512., 1./512.], # dtype=tf.float64) # mode_odds_ratio = tf.expand_dims(mode_odds_ratio, 1) # k = ((num_timesteps+1) * FLAGS.variance) / (2*FLAGS.bimodal_prior_mean) # explain_obs = tf.reduce_sum(model.p.bs) + tf.log(mode_odds_ratio) * k # explain_obs = tf.tile(explain_obs, [num_eval_samples, 1]) # # run the model on the explainable observations # if bound == "iwae": # (_, _, _, explain_states, explain_log_weights) = bounds.iwae( # model, # explain_obs, # num_timesteps, # num_samples=num_eval_samples) # elif bound == "fivo" or "fivo-aux": # (_, _, _, explain_states, explain_log_weights) = bounds.fivo( # model, # explain_obs, # num_timesteps, # resampling_schedule=resampling_schedule, # use_resampling_grads=False, # resampling_type="multinomial", # aux=("aux" in bound), # num_samples=num_eval_samples) # summ.summarize_particles(explain_states, # explain_log_weights, # explain_obs, # model) # Calculate the true likelihood. if hasattr(model.p, 'likelihood') and callable(getattr(model.p, 'likelihood')): eval_likelihood = model.p.likelihood(eval_observations)/ FLAGS.num_timesteps else: eval_likelihood = tf.zeros_like(eval_log_p_hat) tf.summary.scalar("log_p_hat", eval_log_p_hat) tf.summary.scalar("likelihood", eval_likelihood) tf.summary.scalar("bound_gap", eval_likelihood - eval_log_p_hat) summ.summarize_model(model, true_bs, eval_observations, eval_states, bound, summarize_r=not bound == "fivo-aux-td") # Compute and apply grads. global_step = tf.train.get_or_create_global_step() apply_grads = make_apply_grads_op(losses, global_step, learning_rate, lr_decay_steps) # Update the emas after applying the grads. with tf.control_dependencies([apply_grads]): train_op = tf.group(ema_op) #train_op = tf.group(ema_op, add_check_numerics_ops()) return global_step, train_op, eval_log_p_hat, eval_likelihood
args = py.args_from_yaml(py.join(test_args.experiment_dir, 'settings.yml')) args.__dict__.update(test_args.__dict__) # ============================================================================== # = test = # ============================================================================== # data A_img_paths_test = py.glob(py.join(args.datasets_dir, args.dataset, 'testA'), '*.jpg') B_img_paths_test = py.glob(py.join(args.datasets_dir, args.dataset, 'testB'), '*.jpg') A_dataset_test = data.make_dataset(A_img_paths_test, args.batch_size, args.load_size, args.crop_size, training=False, drop_remainder=False, shuffle=False, repeat=1) B_dataset_test = data.make_dataset(B_img_paths_test, args.batch_size, args.load_size, args.crop_size, training=False, drop_remainder=False, shuffle=False, repeat=1) # model G_A2B = module.ResnetGenerator(input_shape=(args.crop_size, args.crop_size, 3), dim=args.dim,
# data div = 900 batch_size = 1 num_workers = 0 data_path = 'data/class1_data.pkl' # model hidden_dim = 32 # make it a number smaller than feature_dim model_check = 'model/checkpoint.pth.tar' model_best = 'model/bestmodel.pth.tar' # result save_path = 'data/pred_data.pkl' # -------------------------------------------------------------------------- # prepare dataset data, (len_seq, num_frame, num_joint, num_coor) = make_dataset(data_path) test_set = data[div :] # test_set = data[0: 30] # train_loader shuffle test_loader = DataLoader(dataset=test_set, batch_size=batch_size, shuffle=False, num_workers=num_workers) # -------------------------------------------------------------------------- # model settings feature_dim = num_joint * num_coor # 16 * 3 = 48 model = LSTMpred(feature_dim, hidden_dim) model.eval() # loading trained model if os.path.isfile(model_best): print(("=> loading checkpoint '{}'".format(model_best))) checkpoint = torch.load(model_best)
s = l[k].split('\\')[-1] s2 = 'data\\tests\\0.1_color\\' + s lis.append(s2) return lis # ============================================================================== # = data = # ============================================================================== B_imgs = py.glob(py.join('data\\tests', 'trainsmall'), '*.jpg') B_color = createdata(B_imgs) B_set = data.make_dataset(B_imgs, B_color, abatch_size, aload_size, acrop_size, training=False, work=0) B_lis = list(tfds.as_numpy(B_set)) B_list = [] for b in B_lis: m, = b B_list.append(tf.convert_to_tensor(m)) B_length = len(B_list) len_dataset = B_length #print('b list\n',B_list[0][0].squeeze().shape) A2B_pool = data.ItemPool(apool_size)
def main(): # data div1, div2 = 800, 900 batch_size = 20 num_workers = 0 data_path = 'data/class1_data.pkl' # train num_epoch = 100 lr = 1e-3 lr_step = 50 # momentum = 0.9 weight_decay = 1e-3 # model hidden_dim = 32 # make it a number smaller than feature_dim model_check = 'model/checkpoint.pth.tar' model_best = 'model/bestmodel.pth.tar' # result print_freq = 20 loss_best = 1e5 # -------------------------------------------------------------------------- # prepare dataset data, (len_seq, num_frame, num_joint, num_coor) = make_dataset(data_path) # data[:div] for trainning, data[800:900] for validation # and the rest for testing train_set = data[:div1] val_set = data[div1:div2] # train_loader shuffle train_loader = DataLoader(dataset=train_set, batch_size=batch_size, shuffle=True, num_workers=num_workers) val_loader = DataLoader(dataset=val_set, batch_size=1, shuffle=False, num_workers=num_workers) # -------------------------------------------------------------------------- # model settings feature_dim = num_joint * num_coor # 16 * 3 = 48 model = LSTMpred(feature_dim, hidden_dim) print(model) criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay) # -------------------------------------------------------------------------- # run for epoch in range(num_epoch): adjust_lr(lr, optimizer, epoch, lr_step) print('Epoch: {0}/{1} [training stage]'.format(epoch, num_epoch)) train(train_loader, model, criterion, optimizer, print_freq) print('Epoch: {0}/{1} [validation stage]'.format(epoch, num_epoch)) loss = val(val_loader, model, criterion, print_freq) is_best = loss < loss_best loss_best = min(loss_best, loss) save_checkpoint( { 'epoch': epoch, 'arch': 'LSTMpred', 'state_dict': model.state_dict(), 'loss_best': loss_best, 'optimizer': optimizer.state_dict(), }, is_best, model_check, model_best)
def create_graph(bound, state_size, num_timesteps, batch_size, num_samples, num_eval_samples, resampling_schedule, use_resampling_grads, learning_rate, lr_decay_steps, train_p, dtype='float64'): if FLAGS.use_bs: true_bs = None else: true_bs = [ np.zeros([state_size]).astype(dtype) for _ in xrange(num_timesteps) ] # Make the dataset. true_bs, dataset = data.make_dataset( bs=true_bs, state_size=state_size, num_timesteps=num_timesteps, batch_size=batch_size, num_samples=num_samples, variance=FLAGS.variance, prior_type=FLAGS.p_type, bimodal_prior_weight=FLAGS.bimodal_prior_weight, bimodal_prior_mean=FLAGS.bimodal_prior_mean, transition_type=FLAGS.transition_type, fixed_observation=FLAGS.fixed_observation, dtype=dtype) itr = dataset.make_one_shot_iterator() _, observations = itr.get_next() # Make the dataset for eval _, eval_dataset = data.make_dataset( bs=true_bs, state_size=state_size, num_timesteps=num_timesteps, batch_size=num_eval_samples, num_samples=num_eval_samples, variance=FLAGS.variance, prior_type=FLAGS.p_type, bimodal_prior_weight=FLAGS.bimodal_prior_weight, bimodal_prior_mean=FLAGS.bimodal_prior_mean, transition_type=FLAGS.transition_type, fixed_observation=FLAGS.fixed_observation, dtype=dtype) eval_itr = eval_dataset.make_one_shot_iterator() _, eval_observations = eval_itr.get_next() # Make the model. if bound == "fivo-aux-td": model = models.TDModel.create( state_size, num_timesteps, variance=FLAGS.variance, train_p=train_p, p_type=FLAGS.p_type, q_type=FLAGS.q_type, mixing_coeff=FLAGS.bimodal_prior_weight, prior_mode_mean=FLAGS.bimodal_prior_mean, observation_variance=FLAGS.observation_variance, transition_type=FLAGS.transition_type, use_bs=FLAGS.use_bs, dtype=tf.as_dtype(dtype), random_seed=FLAGS.random_seed) else: model = models.Model.create( state_size, num_timesteps, variance=FLAGS.variance, train_p=train_p, p_type=FLAGS.p_type, q_type=FLAGS.q_type, mixing_coeff=FLAGS.bimodal_prior_weight, prior_mode_mean=FLAGS.bimodal_prior_mean, observation_variance=FLAGS.observation_variance, transition_type=FLAGS.transition_type, use_bs=FLAGS.use_bs, r_sigma_init=FLAGS.r_sigma_init, dtype=tf.as_dtype(dtype), random_seed=FLAGS.random_seed) # Compute the bound and loss if bound == "iwae": (_, losses, ema_op, _, _) = bounds.iwae(model, observations, num_timesteps, num_samples=num_samples) (eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.iwae(model, eval_observations, num_timesteps, num_samples=num_eval_samples, summarize=True) eval_log_p_hat = tf.reduce_mean(eval_log_p_hat) elif "fivo" in bound: if bound == "fivo-aux-td": (_, losses, ema_op, _, _) = bounds.fivo_aux_td(model, observations, num_timesteps, resampling_schedule=resampling_schedule, num_samples=num_samples) (eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.fivo_aux_td( model, eval_observations, num_timesteps, resampling_schedule=resampling_schedule, num_samples=num_eval_samples, summarize=True) else: (_, losses, ema_op, _, _) = bounds.fivo(model, observations, num_timesteps, resampling_schedule=resampling_schedule, use_resampling_grads=use_resampling_grads, resampling_type=FLAGS.resampling_method, aux=("aux" in bound), num_samples=num_samples) (eval_log_p_hat, _, _, eval_states, eval_log_weights) = bounds.fivo( model, eval_observations, num_timesteps, resampling_schedule=resampling_schedule, use_resampling_grads=False, resampling_type="multinomial", aux=("aux" in bound), num_samples=num_eval_samples, summarize=True) eval_log_p_hat = tf.reduce_mean(eval_log_p_hat) summ.summarize_ess(eval_log_weights, only_last_timestep=True) # if FLAGS.p_type == "bimodal": # # create the observations that showcase the model. # mode_odds_ratio = tf.convert_to_tensor([1., 3., 1./3., 512., 1./512.], # dtype=tf.float64) # mode_odds_ratio = tf.expand_dims(mode_odds_ratio, 1) # k = ((num_timesteps+1) * FLAGS.variance) / (2*FLAGS.bimodal_prior_mean) # explain_obs = tf.reduce_sum(model.p.bs) + tf.log(mode_odds_ratio) * k # explain_obs = tf.tile(explain_obs, [num_eval_samples, 1]) # # run the model on the explainable observations # if bound == "iwae": # (_, _, _, explain_states, explain_log_weights) = bounds.iwae( # model, # explain_obs, # num_timesteps, # num_samples=num_eval_samples) # elif bound == "fivo" or "fivo-aux": # (_, _, _, explain_states, explain_log_weights) = bounds.fivo( # model, # explain_obs, # num_timesteps, # resampling_schedule=resampling_schedule, # use_resampling_grads=False, # resampling_type="multinomial", # aux=("aux" in bound), # num_samples=num_eval_samples) # summ.summarize_particles(explain_states, # explain_log_weights, # explain_obs, # model) # Calculate the true likelihood. if hasattr(model.p, 'likelihood') and callable( getattr(model.p, 'likelihood')): eval_likelihood = model.p.likelihood( eval_observations) / FLAGS.num_timesteps else: eval_likelihood = tf.zeros_like(eval_log_p_hat) tf.summary.scalar("log_p_hat", eval_log_p_hat) tf.summary.scalar("likelihood", eval_likelihood) tf.summary.scalar("bound_gap", eval_likelihood - eval_log_p_hat) summ.summarize_model(model, true_bs, eval_observations, eval_states, bound, summarize_r=not bound == "fivo-aux-td") # Compute and apply grads. global_step = tf.train.get_or_create_global_step() apply_grads = make_apply_grads_op(losses, global_step, learning_rate, lr_decay_steps) # Update the emas after applying the grads. with tf.control_dependencies([apply_grads]): train_op = tf.group(ema_op) #train_op = tf.group(ema_op, add_check_numerics_ops()) return global_step, train_op, eval_log_p_hat, eval_likelihood
def main(args): logger = init_logger(args.run_name) # Datasets img_height, img_width, _ = InceptionV3.SHAPE def prep_func(f, x, y): x = read_image(x) x = decode_png(x) x = resize(x, img_height, img_width) return f, x, y trn_ds = make_dataset(args.train_dir, args.batch_size, prep_func, shuffle=True, repeat=True, add_filenames=True) val_ds = make_dataset(args.train_dir, args.batch_size, prep_func, shuffle=False, repeat=False, add_filenames=True) tst_ds = make_dataset(args.train_dir, args.batch_size, prep_func, shuffle=False, repeat=False, add_filenames=True) num_classes = len(trn_ds.labels_map) it = tf.data.Iterator.from_structure( trn_ds.dataset.output_types, trn_ds.dataset.output_shapes) num_trn_batches = int(math.ceil(float(trn_ds.size) / args.batch_size)) num_val_batches = int(math.ceil(float(val_ds.size) / args.batch_size)) num_tst_batches = int(math.ceil(float(tst_ds.size) / args.batch_size)) trn_init_op = it.make_initializer(trn_ds.dataset) val_init_op = it.make_initializer(val_ds.dataset) tst_init_op = it.make_initializer(tst_ds.dataset) # Filename, input image and corrsponding one hot encoded label f, x, y = it.get_next() sess = tf.Session() # Model and logits is_training = tf.placeholder(dtype=tf.bool) model = InceptionV3(nb_classes=num_classes, is_training=is_training) logits = model.get_logits(x) attacks_ord = { 'inf': np.inf, '1': 1, '2': 2 } # FGM attack attack_params = { 'eps': args.eps, 'clip_min': 0.0, 'clip_max': 1.0, 'ord': attacks_ord[args.ord], } attack = FastGradientMethod(model, sess) # Learning rate with exponential decay global_step = tf.Variable(0, trainable=False) global_step_update_op = tf.assign(global_step, tf.add(global_step, 1)) lr = tf.train.exponential_decay( args.initial_lr, global_step, args.lr_decay_steps, args.lr_decay_factor, staircase=True) cross_entropy = CrossEntropy(model, attack=attack, smoothing=args.label_smth, attack_params=attack_params, adv_coeff=args.adv_coeff) loss = cross_entropy.fprop(x, y) # Gradients clipping opt = tf.train.RMSPropOptimizer(learning_rate=lr, decay=args.opt_decay, epsilon=1.0) gvs = opt.compute_gradients(loss) clip_min, clip_max = -args.grad_clip, args.grad_clip capped_gvs = [] for g, v in gvs: capped_g = tf.clip_by_value(g, clip_min, clip_max) \ if g is not None else tf.zeros_like(v) capped_gvs.append((capped_g, v)) train_op = opt.apply_gradients(capped_gvs) saver = tf.train.Saver() global_init_op = tf.global_variables_initializer() if args.load_model and args.restore_path: saver.restore(sess, args.restore_path) logger.info("Model restored from: ".format(args.restore_path)) with sess.as_default(): sess.run(global_init_op) best_val_acc = -1 for epoch in range(args.num_epochs): logger.info("Epoch: {:04d}/{:04d}".format(epoch + 1, args.num_epochs)) sess.run(trn_init_op) for batch in range(num_trn_batches): loss_np, lr_np, _ = sess.run([loss, lr, train_op], feed_dict={is_training: True}) logger.info("Batch: {:04d}/{:04d}, loss: {:.05f}, lr: {:.05f}" .format(batch + 1, num_trn_batches, loss_np, lr_np)) logger.info("Epoch completed...") sess.run(global_step_update_op) val_acc = eval_acc(sess, logits, y, num_val_batches, is_training, val_init_op) logger.info("Validation set accuracy: {:.05f}".format(val_acc)) if best_val_acc < val_acc: output_path = saver.save(sess, args.model_path) logger.info("Model was successfully saved: {}".format(output_path)) best_val_acc = val_acc pass tst_acc = eval_acc(sess, logits, y, num_tst_batches, is_training, tst_init_op) logger.info("Test set accuracy: {:.05f}".format(tst_acc))
os.mkdir('output') if not os.path.exists(output_dir): os.mkdir(output_dir) # save settings with open(os.path.join(output_dir, 'settings.yml'), "w", encoding="utf-8") as f: yaml.dump(args, f) # others use_gpu = torch.cuda.is_available() device = torch.device("cuda" if use_gpu else "cpu") # dataset data_loader, shape = data.make_dataset(args.dataset, args.batch_size, args.img_size,pin_memory=use_gpu) #n_G_upsamplings = n_D_downsamplings = 5 # 3: 32x32 4:64:64 5:128 6:256 print('data-size: '+str(shape)) # ============================================================================== # = model = # ============================================================================== # networks G = net.Generator(input_dim=args.z_dim, output_channels = args.img_channels, image_size=args.img_size, scale=args.Gscale).to(device) D = net.Discriminator_SpectrualNorm(args.z_dim, input_channels = args.img_channels, image_size=args.img_size, scale=args.Dscale).to(device) with open(output_dir+'/net.txt','w+') as f: #if os.path.getsize(output_dir+'/net.txt') == 0: #判断文件是否为空 print(G,file=f)
os.mkdir(params.checkpoint_dir) os.mkdir(params.log_dir) except FileExistsError: pass configure(params.log_dir) input_dim = 300 output_dim = 512 print('Starting with params:', params) # Pre-process data and create dataloaders ===================================== # %% print('Pre-processing data') (train, valid, test) = data.make_dataset(params) train_loader = dd.DataLoader(dataset=train, batch_size=params.batch_size, shuffle=True) valid_loader = dd.DataLoader(dataset=valid, batch_size=params.batch_size, shuffle=True) test_loader = dd.DataLoader(dataset=test, batch_size=params.batch_size, shuffle=True) # Create model, optimizer, and criterion ====================================== print('Creating model') model = models.LinearDifference(input_dim, output_dim) if params.model_path != '':