def main(): print('Preparing data') if args.dataset == 'cocotext': # Similar Number of classes as Con-Text (Proxy Task) num_classes = 28 weight_file = '/tmp-network/user/rsampaio/models/finegrained-classif/context_RMAC_Full_fisher_yolo_phoc_mlb_ep3.0/checkpoint_mlb_3.0_L1_0.7800202876657005.weights' else: print('Dataset error') embedding_size = get_embedding_size(args.embedding) print('Loading Model') net = load_model(args, num_classes, embedding_size) checkpoint = load_checkpoint(weight_file) net.load_state_dict(checkpoint) print('Checking CUDA') if args.cuda and args.ngpu > 1: print('\t* Data Parallel **NOT TESTED**') net = torch.nn.DataParallel(net, device_ids=list(range(args.ngpu))) if args.cuda: print('\t* CUDA ENABLED!') net = net.cuda() print('\n*** TEST ***\n') test(args, net, args.cuda) print('*** Feature Extraction Completed ***') sys.exit()
def main(): print('Preparing data') if args.dataset == 'context': num_classes = 28 weight_file = '/SSD/fine_grained_classification_with_textual_cues/backup/context_orig_fisherNet_fisher_yolo_phoc_concat/checkpoint7988.weights' else: num_classes = 20 weight_file = '/SSD/fine_grained_classification_with_textual_cues/backup/bottles_orig_fisherNet_fisher_yolo_phoc_concat/checkpoint7690.weights' embedding_size = get_embedding_size(args.embedding) print('Loading Model') net = load_model(args, num_classes, embedding_size) checkpoint = load_checkpoint(weight_file) net.load_state_dict(checkpoint) print('Checking CUDA') if args.cuda and args.ngpu > 1: print('\t* Data Parallel **NOT TESTED**') net = torch.nn.DataParallel(net, device_ids=list(range(args.ngpu))) if args.cuda: print('\t* CUDA ENABLED!') net = net.cuda() print('\n*** TEST ***\n') test(args, net, args.cuda, num_classes) print('*** Feature Extraction Completed ***') sys.exit()
def keract_visual(model_path, x=None): if x is None: raise ValueError('x cannot be None.') model = load_model(model_path) visualizer = vis.Visualizer(model, x) visualizer.init_model_activations() visualizer.display_model_activations()
def __init__(self, debug=False): _, (self.test_x, self.test_y) = load_data('mnist') self.debug = debug if not debug: self.model_names = os.listdir('data/models') else: self.model_names = os.listdir('data/models')[:2] self.model_models = {} print("Loading models") for tmp in self.model_names: self.model_models[tmp] = models.load_model(tmp) print("Finished loading models!")
def init_candidate_targets(weak_defenses_file): """ :return: the list of candidate targets, which are sorted descendingly according to their effectiveness. """ # load all models candidates = {} waives = get_waive_list() with open(os.path.join(PATH.MODEL, weak_defenses_file), 'r') as weak_defense_list: for weak_defense in weak_defense_list: weak_defense = weak_defense[:-1] # remove the \newline character print('...Loading weak defense {}'.format(weak_defense)) name = weak_defense.split('.')[0].split('-')[-1] if name in waives: print('Ignore [{}]'.format(name)) continue candidates[name] = load_model(weak_defense) return candidates
def main(): print('Preparing data') num_classes = get_num_classes(args) embedding_size = get_embedding_size(args.embedding) grad_clip = args.grad_clip train_data, test_data, gt_annotations, text_embedding = load_data( args, embedding_size) #sampler = torch.utils.data.sampler.WeightedRandomSampler(weights, len(weights)) train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.prefetch, pin_memory=True) test_loader = DataLoader(test_data, batch_size=args.batch_size, shuffle=True, num_workers=args.prefetch, pin_memory=True) print('Creating Model') net = load_model(args, num_classes, embedding_size) print('Optimizer: ', args.optim) if args.optim == 'sgd': optim = torch.optim.SGD(net.parameters(), args.learning_rate, momentum=args.momentum, weight_decay=args.decay, nesterov=True) elif args.optim == 'adam': optim = torch.optim.Adam(filter(lambda p: p.requires_grad, net.parameters()), args.learning_rate, betas=(0.9, 0.999), eps=1e-08, weight_decay=args.decay) elif args.optim == 'radam': optim_base = RAdam(filter(lambda p: p.requires_grad, net.parameters()), args.learning_rate) optim = Lookahead(optim_base, k=5, alpha=0.5) else: print("Optimizer not implemented") net_params = net.parameters() # Weight Tensor for Criterion weights = get_weight_criterion(args.dataset) class_weights = torch.FloatTensor(weights).cuda() criterion = nn.CrossEntropyLoss(weight=class_weights) evaluation = None print('Checking CUDA') if args.cuda and args.ngpu > 1: print('\t* Data Parallel **NOT TESTED**') net = torch.nn.DataParallel(net, device_ids=list(range(args.ngpu))) if args.cuda: print('\t* CUDA ENABLED!') net = net.cuda() criterion = criterion.cuda() # Init variables early_stop_counter, start_epoch, best_perf = 0, 0, 0 if args.load is not None: checkpoint = load_checkpoint(args.load) net.load_state_dict(checkpoint) if args.test == 'False': for epoch in range(start_epoch, args.epochs): # Update learning rate adjust_learning_rate(optim, epoch) print('\n*** TRAIN ***\n') loss = train(train_loader, net, optim, args.cuda, criterion, epoch, args.log_interval, num_classes, args.batch_size, net_params, grad_clip) print('\n*** TEST ***\n') performance = test(test_loader, net, args.cuda, num_classes, args.batch_size, args) # Early-Stop + Save model if performance > best_perf: best_perf = performance best_epoch = epoch early_stop_counter = 0 if args.save_weights == 'True': save_checkpoint(net, best_perf, directory=args.save, file_name='checkpoint', data_weights=args.dataset) else: if early_stop_counter == args.early_stop: print('\nEarly stop reached!') break early_stop_counter += 1 # Load Best model in case of save it print("\nBest Performance is: %f at Epoch No. %d" % (best_perf, best_epoch)) else: print('\n*** TEST ***\n') performance = test(test_loader, net, args.cuda, num_classes, args.batch_size, args) print('*** Process Completed ***') sys.exit()
def train(): train_loader = generator.Generator(args.dataset_root, args, partition='train', dataset=args.dataset) logger.info('Batch size: ' + str(args.batch_size)) #Try to load models enc_nn = models.load_model('enc_nn', args) metric_nn = models.load_model('metric_nn', args) if enc_nn is None or metric_nn is None: enc_nn, metric_nn = models.create_models(args=args) softmax_module = models.SoftmaxModule() if args.cuda: enc_nn.cuda() metric_nn.cuda() logger.info(str(enc_nn)) logger.info(str(metric_nn)) weight_decay = 0 if args.dataset == 'mini_imagenet': logger.info('Weight decay ' + str(1e-6)) weight_decay = 1e-6 opt_enc_nn = optim.Adam(enc_nn.parameters(), lr=args.lr, weight_decay=weight_decay) opt_metric_nn = optim.Adam(metric_nn.parameters(), lr=args.lr, weight_decay=weight_decay) model_summary([enc_nn, metric_nn]) optimizer_summary([opt_enc_nn, opt_metric_nn]) enc_nn.train() metric_nn.train() counter = 0 total_loss = 0 val_acc, val_acc_aux = 0, 0 test_acc = 0 for batch_idx in range(args.iterations): #################### # Train #################### data = train_loader.get_task_batch( batch_size=args.batch_size, n_way=args.train_N_way, unlabeled_extra=args.unlabeled_extra, num_shots=args.train_N_shots, cuda=args.cuda, variable=True) [ batch_x, label_x, _, _, batches_xi, labels_yi, oracles_yi, hidden_labels ] = data opt_enc_nn.zero_grad() opt_metric_nn.zero_grad() loss_d_metric = train_batch(model=[enc_nn, metric_nn, softmax_module], data=[ batch_x, label_x, batches_xi, labels_yi, oracles_yi, hidden_labels ]) opt_enc_nn.step() opt_metric_nn.step() adjust_learning_rate(optimizers=[opt_enc_nn, opt_metric_nn], lr=args.lr, iter=batch_idx) #################### # Display #################### counter += 1 total_loss += loss_d_metric.data[0] if batch_idx % args.log_interval == 0: display_str = 'Train Iter: {}'.format(batch_idx) display_str += '\tLoss_d_metric: {:.6f}'.format(total_loss / counter) logger.info(display_str) counter = 0 total_loss = 0 #################### # Test #################### if (batch_idx + 1) % args.test_interval == 0 or batch_idx == 20: if batch_idx == 20: test_samples = 100 else: test_samples = 3000 if args.dataset == 'mini_imagenet': val_acc_aux = test.test_one_shot( args, model=[enc_nn, metric_nn, softmax_module], test_samples=test_samples * 5, partition='val') test_acc_aux = test.test_one_shot( args, model=[enc_nn, metric_nn, softmax_module], test_samples=test_samples * 5, partition='test') test.test_one_shot(args, model=[enc_nn, metric_nn, softmax_module], test_samples=test_samples, partition='train') enc_nn.train() metric_nn.train() if val_acc_aux is not None and val_acc_aux >= val_acc: test_acc = test_acc_aux val_acc = val_acc_aux if args.dataset == 'mini_imagenet': logger.info("Best test accuracy {:.4f} \n".format(test_acc)) #################### # Save model #################### if (batch_idx + 1) % args.save_interval == 0: logger.info("saving model...") torch.save(enc_nn, os.path.join(logger.get_logger_dir(), 'enc_nn.t7')) torch.save(metric_nn, os.path.join(logger.get_logger_dir(), 'metric_nn.t7')) # Test after training test.test_one_shot(args, model=[enc_nn, metric_nn, softmax_module], test_samples=args.test_samples)
def get_adversarial_examples(model_name, attack_method, X, Y, **kwargs): # remove the file format model_name = model_name.split('.')[0] dataset = DATA.CUR_DATASET_NAME if ((not os.path.isfile('{}/{}.h5'.format(PATH.MODEL, model_name))) and (not os.path.isfile('{}/{}.json'.format(PATH.MODEL, model_name)))): raise FileNotFoundError( 'Could not file target mode [{}].'.format(model_name)) config = tf.ConfigProto(intra_op_parallelism_threads=4, inter_op_parallelism_threads=4) sess = tf.Session(config=config) keras.backend.set_session(sess) model = load_model(model_name) logger.info('Crafting adversarial examples using {} method...'.format( attack_method.upper())) X_adv = None if (attack_method == ATTACK.FGSM): eps = kwargs.get('eps', 0.25) attack_params = { 'eps': eps, 'ord': np.inf, 'clip_min': 0., 'clip_max': 1. } logger.info('{}: (eps={})'.format(attack_method.upper(), eps)) start_time = time.time() X_adv, Y = whitebox.generate_art(model, X, Y, attack_method, dataset, attack_params) # X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) duration = time.time() - start_time logger.info('Time cost for generation: {}'.format(duration)) elif (attack_method == ATTACK.BIM): # iterative fast gradient method eps = kwargs.get('eps', 0.25) nb_iter = kwargs.get('nb_iter', 100) ord = kwargs.get('ord', np.inf) """ Cleverhans requires an eps_iter that is smaller than the eps. By default, eps_iter=0.05, so, update eps_iter for small epsilons. """ if eps < 0.005: eps_iter = 0.001 elif eps < 0.05: eps_iter = 0.005 else: # for big enough eps, use the default setting eps_iter = 0.05 attack_params = { 'eps': eps, 'eps_iter': eps_iter, 'nb_iter': nb_iter, 'ord': ord, 'clip_min': 0., 'clip_max': 1. } logger.info('{}: (ord={}, nb_iter={}, eps={})'.format( attack_method.upper(), ord, nb_iter, eps)) start_time = time.time() X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) duration = time.time() - start_time print('Time cost: {}'.format(duration)) elif (attack_method == ATTACK.DEEPFOOL): # Images for inception classifier are normalized to be in [0, 255] interval. # max_iterations = kwargs.get('max_iterations', 100) # keras.backend.set_learning_phase(True) max_iterations = 50 ord = kwargs.get('ord', 2) overshoot = kwargs.get('overshoot', 0.02) attack_params = { 'ord': ord, 'max_iterations': max_iterations, 'nb_candidate': int(Y.shape[1] / 2), 'overshoot': overshoot, 'clip_min': 0., 'clip_max': 255. } print(attack_params) logger.info('{}: (max_iterations={})'.format(attack_method.upper(), max_iterations)) X *= 255. Y *= 255 start_time = time.time() X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) X /= 255. Y /= 255. X_adv /= 255. duration = time.time() - start_time print('Time cost: {}'.format(duration)) elif (attack_method == ATTACK.CW_L2): ord = 2 binary_search_steps = kwargs.get('binary_search_steps', 10) batch_size = kwargs.get('cw_batch_size', 2) initial_const = kwargs.get('initial_const', 10) learning_rate = kwargs.get('learning_rate', 0.1) max_iterations = kwargs.get('max_iterations', 100) attack_params = { 'batch_size': batch_size, 'binary_search_steps': binary_search_steps, 'initial_const': initial_const, 'learning_rate': learning_rate, 'max_iterations': max_iterations, 'clip_min': 0., 'clip_max': 1. } logger.info('{}: (ord={}, max_iterations={})'.format( attack_method.upper(), ord, max_iterations)) start_time = time.time() X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) duration = time.time() - start_time logger.info('Time cost: {}'.format(duration)) elif (attack_method == ATTACK.CW_Linf): ord = np.inf decrease_factor = kwargs.get('decrease_factor', 0.9) initial_const = kwargs.get('initial_const', 1e-5) learning_rate = kwargs.get('learning_rate', 0.1) largest_const = kwargs.get('largest_const', 2e+1) max_iterations = kwargs.get('max_iterations', 1000) reduce_const = False const_factor = 3.0 attack_params = { # 'descrease_factor': decrease_factor, 'initial_const': initial_const, 'learning_rate': learning_rate, 'max_iterations': max_iterations, 'largest_const': largest_const, 'reduce_const': reduce_const, 'const_factor': const_factor, 'clip_min': 0., 'clip_max': 1. } logger.info('{}: (ord={}, max_iterations={})'.format( attack_method.upper(), ord, max_iterations)) start_time = time.time() X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) duration = time.time() - start_time logger.info('Time cost: {}'.format(duration)) elif (attack_method == ATTACK.CW_L0): max_iterations = kwargs.get('max_iterations', 1000) initial_const = kwargs.get('initial_const', 10) largest_const = kwargs.get('largest_const', 15) attack_params = { 'max_iterations': max_iterations, 'initial_const': initial_const, 'largest_const': largest_const } X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, attack_params) elif (attack_method == ATTACK.JSMA): theta = kwargs.get('theta', 0.6) gamma = kwargs.get('gamma', 0.5) attack_params = { 'theta': theta, 'gamma': gamma, 'clip_min': 0., 'clip_max': 1. } logger.info('{}: (theta={}, gamma={})'.format(attack_method.upper(), theta, gamma)) start_time = time.time() X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) duration = time.time() - start_time logger.info('Time cost: {}'.format(duration)) elif (attack_method == ATTACK.PGD): eps = kwargs.get('eps', 0.3) nb_iter = kwargs.get('nb_iter', 40) eps_iter = kwargs.get('eps_iter', 0.01) attack_params = { 'eps': eps, 'clip_min': 0., 'clip_max': 1., 'nb_iter': nb_iter, 'eps_iter': eps_iter } start_time = time.time() X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) duration = time.time() - start_time logger.info('Time cost: {}'.format(duration)) elif (attack_method == ATTACK.ONE_PIXEL): # one-pixel was implemented separately. targeted = kwargs.get('targeted', False) pixel_counts = kwargs.get('pixel_counts', 3) max_iter = kwargs.get('max_iter', 10) pop_size = kwargs.get('pop_size', 10) attack_params = { 'targeted': targeted, 'pixel_counts': pixel_counts, 'max_iter': max_iter, 'pop_size': pop_size, 'clip_min': 0., 'clip_max': 1., } start_time = time.monotonic() X_adv, Y = one_pixel.generate(model, X, Y, attack_params) duration = time.monotonic() - start_time logger.info('Time cost: {}'.format(duration)) elif (attack_method == ATTACK.MIM): eps = kwargs.get('eps', 0.3) eps_iter = kwargs.get('eps_iter', 0.06) nb_iter = kwargs.get('nb_iter', 10) decay_factor = kwargs.get('decay_factor', 0.5) y_target = kwargs.get('y_target', None) attack_params = { 'eps': eps, 'eps_iter': eps_iter, 'nb_iter': nb_iter, 'ord': np.inf, 'decay_factor': decay_factor, 'y_target': y_target, 'clip_min': 0., 'clip_max': 1. } start_time = time.time() X_adv, Y = whitebox.generate(sess, model, X, Y, attack_method, dataset, attack_params) duration = time.time() - start_time logger.info('Time cost: {}'.format(duration)) print('*** SHAPE: {}'.format(np.asarray(X_adv).shape)) del model sess.close() return X_adv, Y
def main(): print('Preparing data') data_path = args.base_dir if args.dataset == 'context': num_classes = 28 weight_file = '/SSD/GCN_classification/best/context_fullGCN_bboxes_fasttext_google_ocr_concat_mean_split1/checkpoint_context.weights' with open(data_path + '/Context/data/split_1.json', 'r') as fp: gt_annotations = json.load(fp) with open( data_path + '/Context/' + args.ocr + '/text_embeddings/Context_' + args.embedding + '.json', 'r') as fp: text_embedding = json.load(fp) # Load Local features from Faster R-CNN VG with open(data_path + '/Context/context_local_feats.npy', 'rb') as fp: local_feats = np.load(fp, encoding='bytes') # Create img_name to index of local features with open(data_path + '/Context/context_local_feats_image_ids.txt', 'r') as fp: image_ids = fp.readlines() image_name2features_index = {} for item in image_ids: img_name = item.strip().split(',')[0].split('/')[-1].replace( '\'', '') idx = item.strip().split(',')[1].replace(')', '').replace(' ', '') image_name2features_index[img_name] = idx # BBOXES LOADING FOR TEXT FEATURES # Load BBOXES of Scene Text with open(data_path + '/Context/google_ocr/bboxes/Context_bboxes.json', 'r') as fp: text_bboxes = json.load(fp) # Load BBOXES of Local Visual Features with open(data_path + '/Context/context_bboxes.npy', 'rb') as fp: local_bboxes = np.load(fp, encoding='bytes') else: num_classes = 20 weight_file = '/SSD/GCN_classification/best/bottles_fullGCN_bboxes_fasttext_google_ocr_concat_mean_split2/checkpoint_bottles.weights' with open(data_path + '/Drink_Bottle/split_2.json', 'r') as fp: gt_annotations = json.load(fp) with open( data_path + '/Drink_Bottle/' + args.ocr + '/text_embeddings/Drink_Bottle_' + args.embedding + '.json', 'r') as fp: text_embedding = json.load(fp) # Load Local features from Faster R-CNN VG with open(data_path + '/Drink_Bottle/bottles_local_feats.npy', 'rb') as fp: local_feats = np.load(fp, encoding='bytes') # Create img_name to index of local features with open( data_path + '/Drink_Bottle/bottles_local_feats_image_ids.txt', 'r') as fp: image_ids = fp.readlines() image_name2features_index = {} for item in image_ids: # Sample: ('/SSD/Datasets/Drink_Bottle/images/14/982.jpg', 0) img_name = item.strip().split(',')[0].replace('\'', '').split('/')[-3:] img_name = img_name[0] + '/' + img_name[1] + '/' + img_name[2] idx = item.strip().split(',')[1].replace(')', '').replace(' ', '') image_name2features_index[img_name] = idx # BBOXES LOADING FOR TEXT FEATURES # Load BBOXES of Scene Text with open( data_path + '/Drink_Bottle/google_ocr/bboxes/Drink_Bottle_bboxes.json', 'r') as fp: text_bboxes = json.load(fp) # Load BBOXES of Local Visual Features with open(data_path + '/Drink_Bottle/bottles_bboxes.npy', 'rb') as fp: local_bboxes = np.load(fp, encoding='bytes') embedding_size = get_embedding_size(args.embedding) print('Loading Model') net = load_model(args, num_classes, embedding_size) checkpoint = load_checkpoint(weight_file) net.load_state_dict(checkpoint) print('Checking CUDA') if args.cuda and args.ngpu > 1: print('\t* Data Parallel **NOT TESTED**') net = torch.nn.DataParallel(net, device_ids=list(range(args.ngpu))) if args.cuda: print('\t* CUDA ENABLED!') net = net.cuda() print('\n*** TEST ***\n') test(args, net, args.cuda, num_classes, gt_annotations, text_embedding, local_feats, image_name2features_index, text_bboxes, local_bboxes) print('*** Feature Extraction Completed ***') sys.exit()
def gen_greedy(dataset, attacker=ATTACK.FGSM, attack_count=None, strategy=ATTACK_STRATEGY.RANDOM.value): config = tf.ConfigProto(intra_op_parallelism_threads=4, inter_op_parallelism_threads=4) sess = tf.Session(config=config) keras.backend.set_session(sess) # candidates = init_candidate_targets('ensemble/mnist_weak_defenses_fsgm.list') model_names = os.listdir('data/models') candidates = {} if MODE.DEBUG: tmp = model_names[:2] else: tmp = model_names for name in tmp: candidates[name.split('.')[0]] = load_model(name) print('...In total {} weak defenses.'.format(len(candidates))) prefix = 'wb' # white-box if attack_count == None or attack_count <= 0: prefix = 'gb' # gray-box attack_count = len(candidates.keys()) X_adv = [] _, (X, Y) = load_data(dataset=dataset) # generate 500 samples batch_size = 100 nb_samples = Y.shape[0] nb_iter = int(nb_samples / batch_size) if MODE.DEBUG: X = X[:5] Y = Y[:5] batch_size = 1 start = time.monotonic() for i in range(nb_iter): start_idx = i * batch_size end_idx = min((i + 1) * batch_size, nb_samples) print(start_idx, end_idx) X_batch = X[start_idx:end_idx] Y_batch = Y[start_idx:end_idx] print('...In total {} inputs.'.format(Y.shape[0])) idx = 0 for x, y in zip(X_batch, Y_batch): print('{}-th input...'.format(idx)) x = np.expand_dims(x, axis=0) strategy = ATTACK_STRATEGY.RANDOM.value ''' generate_single(sess, x, y, attacker=ATTACK.FGSM, candidates=None, attack_count=None, max_perturb=get_perturb_upperbound(), strategy=ATTACK_STRATEGY.RANDOM.value) ''' start_sample = time.monotonic() X_adv.append( generate_single(sess, x, y, attacker, candidates, attack_count, strategy=strategy)) end_sample = time.monotonic() print('({}, {})-th sample: {}\n\n'.format( i, idx, (end_sample - start_sample))) idx += 1 save_adv_examples(np.asarray(X_adv), prefix=prefix, bs_samples=X_batch, dataset=dataset, transformation=strategy, attack_method=attacker, attack_params='eps100_batchsize{}_{}'.format( batch_size, i)) duration = time.monotonic() - start print('----------------------------------') print(' Summary') print('----------------------------------') print('Number of inputs:', Y.shape[0]) print('Adversary:', attacker) print('Strategy:', strategy) print('Time cost:', duration) sess.close()
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2" # To disable the tf warning for compiling in SEE4.2 # 0 = all logs, 1 = info, 2 = warnings, 3 = error # Arguments ############################################################################### try: args = get_args() config = process_config(args.config) except: logging.error("Missing or invalid arguments.") exit(0) # Loading model ############################################################################## model_formicID = load_model(config=config, num_species=97) model_formicID = compile_model(model=model_formicID, config=config) model_formicID = weights_load( model=model_formicID, weights= "experiments/T97_CaAll_QuM_ShP_AugM_D05_LR0001_E200_I4_def_clean/checkpoint/weights_76-1.83.hdf5", ) # predicting ############################################################################## Y_true, Y_pred, labels, species_dict = predictor( model=model_formicID, config=config, species_json="data/species_dict.json", plot=True, n_img=10,
def main(): # Arguments ########################################################################### try: args = get_args() config = process_config(args.config) except: logging.error("Missing or invalid arguments.") exit(0) # Logging ########################################################################### logging.basicConfig( filename=os.path.join("logs", config.exp_name + ".log"), format="[%(asctime)s] - [%(levelname)s]: %(message)s", filemode="a", level=logging.DEBUG, ) logging.info("Logging started.") logging.info("Keras version: {}".format(keras_version)) # Session ########################################################################### sess = tf.Session() K.set_session(sess) # create experiment related directories ########################################################################### create_dirs([config.summary_dir, config.checkpoint_dir]) # Initialize the model ########################################################################### model_formicID = load_model(config=config, num_species=97) model_formicID = compile_model(model=model_formicID, config=config) model_formicID = weights_load( model=model_formicID, weights= "experiments/T97_CaAll_QuM_ShSti_AugM_D05_LR0001_E200_I4_def_clean/checkpoint/weights_55-1.76.hdf5", ) # Training in batches with iterator ########################################################################### history = trainer_dir( model=model_formicID, config=config, callbacks=build_logger(config=config, model=model_formicID), ) save_model(model=model_formicID, filename="final_weights.hdf5", config=config) # Evaluation ########################################################################### plot_history(history=history, config=config, theme="ggplot", save=None) evaluator(model=model_formicID, config=config, test_dir=None) # Testing ########################################################################### Y_true, Y_pred, labels, species_dict = predictor( model=model_formicID, config=config, # species_json="data/species_dict.json", plot=True, n_img=10, n_cols=3, ) predictor_reports( Y_true=Y_true, Y_pred=Y_pred, config=config, species_dict=species_dict, target_names=labels, digits=5, ) plot_confusion_matrix( Y_pred=Y_pred, Y_true=Y_true, config=config, target_names=labels, species_dict=species_dict, title=None, cmap="viridis", normalize=True, scores=True, score_size=8, save="confusion_matrix.png", ) # Footer ########################################################################### K.clear_session() logging.info("Logging ended.")
def train(): """Main function used for training for model. Keeps iterating and updating parameters until early stop condition is reached.""" #Generator is used to sample bacthes. train_loader = generator.Generator(args.dataset_root, args, partition='train', dataset=args.dataset) io.cprint('Batch size: ' + str(args.batch_size)) print("Learning rate is " + str(args.lr)) #Try to load models enc_nn = models.load_model('enc_nn', args, io) metric_nn = models.load_model('metric_nn', args, io) #creates models if enc_nn is None or metric_nn is None: enc_nn, metric_nn = models.create_models(args, train_loader) softmax_module = models.SoftmaxModule() if args.cuda: enc_nn.cuda() metric_nn.cuda() io.cprint(str(enc_nn)) io.cprint(str(metric_nn)) weight_decay = 0 if args.dataset == 'sensor': print('Weight decay ' + str(1e-6)) weight_decay = 1e-6 opt_enc_nn = optim.Adam(filter(lambda p: p.requires_grad, enc_nn.parameters()), lr=args.lr, weight_decay=weight_decay) opt_metric_nn = optim.Adam(metric_nn.parameters(), lr=args.lr, weight_decay=weight_decay) enc_nn.train() metric_nn.train() counter = 0 total_loss = 0 test_cycle = 0 batch_idx = 0 start = time.time() print("starting time count") e_stop = early_stop.EarlyStopping() #Start training loop while e_stop.early_stop is False: #################### # Train #################### #Load training batch data, _ = train_loader.get_task_batch(batch_size=args.batch_size, cuda=args.cuda, variable=True) [batch_x, label_x, _, _, batches_xi, labels_yi] = data opt_enc_nn.zero_grad() opt_metric_nn.zero_grad() #Calculate loss loss_d_metric = train_batch( model=[enc_nn, metric_nn, softmax_module], data=[batch_x, label_x, batches_xi, labels_yi]) #Update parameter opt_enc_nn.step() opt_metric_nn.step() #Adjust learning rate adjust_learning_rate(optimizers=[opt_enc_nn, opt_metric_nn], lr=args.lr, iter=batch_idx) #################### # Display #################### counter += 1 total_loss += loss_d_metric.item() if batch_idx % args.log_interval == 0: display_str = 'Train Iter: {}'.format(batch_idx) display_str += '\tLoss_d_metric: {:.6f}'.format(total_loss / counter) io.cprint(display_str) counter = 0 total_loss = 0 #################### # Test #################### #Testing at specific itnervals if (batch_idx + 1) % args.test_interval == 0 or batch_idx == 0: if batch_idx == 20: test_samples = 200 else: test_samples = 300 e_stop = test.test_one_shot( e_stop, test_cycle, args, model=[enc_nn, metric_nn, softmax_module], test_samples=test_samples, partition='val') enc_nn.train() metric_nn.train() test_cycle = test_cycle + 1 end = time.time() io.cprint("Time elapsed : " + str(end - start)) print("Time elapsed : " + str(end - start)) #################### # Save model #################### #Save model at specific interval if (batch_idx + 1) % args.save_interval == 0: torch.save(enc_nn, 'checkpoints/%s/models/enc_nn.t7' % args.exp_name) torch.save(metric_nn, 'checkpoints/%s/models/metric_nn.t7' % args.exp_name) batch_idx = batch_idx + 1 #Test after training #Load best model final_enc_nn = models.load_best_model('enc_nn', io) final_metric_nn = models.load_best_model('metric_nn', io) final_enc_nn.cuda() final_metric_nn.cuda() test.test_one_shot(e_stop, test_cycle, args, model=[final_enc_nn, final_metric_nn, softmax_module], test_samples=args.test_samples, partition='test')