def main(): param_file, data_set, network_params, optimizer_params, debug = setup() if data_set == CIFAR10: (train_images, train_labels, cv_images, cv_labels, test_images, test_labels) = load_data(CIFAR10) if debug: train_images = train_images[0:100] train_labels = train_labels[0:100] in_dim = (32, 32, 3) d_out = 10 elif data_set == MNIST: (train_images, train_labels, cv_images, cv_labels, test_images, test_labels) = load_data(MNIST) in_dim = (28, 28, 1) d_out = 10 else: raise ValueError('Invalid data_set {}'.format(data_set)) bnn = BinaryNeuralNetwork( in_dim=in_dim, out_dim=d_out, network_params=network_params, optimizer_params=optimizer_params, param_file=param_file ) bnn.fit(train_images, train_labels, cv_images, cv_labels)
def model_logistic_regression(sample): x_train, x_test, y_train, y_test = load_data() logistic_regression = LogisticRegression() fit_log_reg = logistic_regression.fit(x_train, y_train) prediction = fit_log_reg.predict(sample) prob = fit_log_reg.predict_proba(sample) return prediction, prob
def benchmark_ensemble_selection(args): from ensemble.ensemble_selection.ensemble_selection import EnsembleSelection task_type = STRING_TO_TASK_TYPES[args.task_type] path = args.data_path metric = CLASSIFICATION_METRICS[args.metric] X, y, X_test, y_test = load_data(path) print(X.shape) if args.n_init and args.replacements: n_init = int(args.n_init) model = EnsembleSelection(task_type, metric, no_iterations=1000, sorted_initialization=True, with_replacements=True, n_init=n_init) name = "EnsembleSelectionSortedInitialization_WithReplacements" elif args.n_init: n_init = int(args.n_init) model = EnsembleSelection(task_type, metric, no_iterations=1000, sorted_initialization=True, n_init=n_init) name = "EnsembleSelectionSortedInitialization" elif args.replacements: model = EnsembleSelection(task_type, metric, no_iterations=1000, with_replacements=True) name = "EnsembleSelectionReplacements" else: model = EnsembleSelection(task_type, metric, no_iterations=1000) name = "EnsembleSelection" return apply_model(args, X=X, y=y, X_test=X_test, y_test=y_test, metric=metric, task_type=task_type, model=model, name=name, dataset=get_datasetname(path))
def setUpGlobal(cls): path = './data/datasets/75191' a, b, c, d = load_data(path) cls.basemodels_preds = a cls.train_y = b cls.test_preds = c cls.test_y = d
def benchmark_stacking_mlr(args): from ensemble.stacking.stacking_MLR import StackingMLR task_type = STRING_TO_TASK_TYPES[args.task_type] path = args.data_path name = "StackingMLR" metric = CLASSIFICATION_METRICS[args.metric] X, y, X_test, y_test = load_data(path) model = StackingMLR() return apply_model(args, X=X, y=y, X_test=X_test, y_test=y_test, metric=metric, task_type=task_type, model=model, name=name, dataset=get_datasetname(path))
def benchmark_stacking_bayesian_avg_mcmc(args): from ensemble.stacking.stacking_bayesian_avg_mcmc import BayesianAverageMCMC task_type = STRING_TO_TASK_TYPES[args.task_type] path = args.data_path name = "StackingBayesianAverageMCMC" metric = CLASSIFICATION_METRICS[args.metric] X, y, X_test, y_test = load_data(path) model = BayesianAverageMCMC(n_samples=10000) return apply_model(args, X=X, y=y, X_test=X_test, y_test=y_test, metric=metric, task_type=task_type, model=model, name=name, dataset=get_datasetname(path))
def benchmark_stacking_agnostic_bayesian(args): from ensemble.stacking.stacking_agnostic_bayesian import AgnosticBayesian task_type = STRING_TO_TASK_TYPES[args.task_type] path = args.data_path name = "StackingAgnosticBayesian" metric = CLASSIFICATION_METRICS[args.metric] X, y, X_test, y_test = load_data(path) model = AgnosticBayesian(task_type, metric, n_bootstraps=500) return apply_model(args, X=X, y=y, X_test=X_test, y_test=y_test, metric=metric, task_type=task_type, model=model, name=name, dataset=get_datasetname(path))
def predictor_gradient_boosting(): new_sample = pd.read_csv('/Users/karola/PycharmProjects/breast_cancer/data/test_samples/sample.csv') # print(np.array(new_sample.transpose)) x_train, x_test, y_train, y_test = load_data() xgboost = XGBClassifier() fit_xgboost = xgboost.fit(x_train, y_train) # print(x_test) # print(x_test.iloc[1].transpose) prediction = fit_xgboost.predict(new_sample) print(prediction) return prediction
def benchmark_best_model(args): task_type = STRING_TO_TASK_TYPES[args.task_type] path = args.data_path dataset = get_datasetname(path) metric = CLASSIFICATION_METRICS[args.metric] name = "SINGLE BEST" X, y, X_test, y_test = load_data(path) n_basemodels = X.shape[0] best_model = np.argmax(calculate_score(y, X[m,:,:], task_type, metric) for m in range(n_basemodels)) perf = calculate_score(y_test, X_test[best_model, :, :], task_type, metric) return {dataset: {name: {str(metric): perf}}}
def benchmark_stacking_bayesian_avg(args): from ensemble.stacking.stacking_bayesian_avg import BayesianAverage task_type = STRING_TO_TASK_TYPES[args.task_type] path = args.data_path name = "StackingBayesianAverage" metric = CLASSIFICATION_METRICS[args.metric] X, y, X_test, y_test = load_data(path) if args.multi: model = BayesianAverage(multi=True) name = "StackingBayesianAverageMultiClass" model = BayesianAverage() name = "StackingBayesianAverageBinaryClass" return apply_model(args, X=X, y=y, X_test=X_test, y_test=y_test, metric=metric, task_type=task_type, model=model, name=name, dataset=get_datasetname(path))
def benchmark_stacking_logit_reg(args): from ensemble.stacking.stacking_logit_reg import StackingLogitReg task_type = STRING_TO_TASK_TYPES[args.task_type] path = args.data_path name = "StackingLogitReg" metric = CLASSIFICATION_METRICS[args.metric] X, y, X_test, y_test = load_data(path) if args.reg_l1: model = StackingLogitReg(regularizer="l1") name = "StackingLogitRegularized_l1" model = StackingLogitReg(regularizer="l2") name = "StackingLogitRegularized_l2" return apply_model(args, X=X, y=y, X_test=X_test, y_test=y_test, metric=metric, task_type=task_type, model=model, name=name, dataset=get_datasetname(path))
def setUpGlobal(cls): """ dataset = datasets.load_breast_cancer() X = dataset.data y = dataset.target a, b, c, d = compute_level1_dataset(X, y) cls.basemodels_preds = a cls.test_preds = b cls.train_y = c cls.test_y = d """ path = "./data/datasets/75103" print("data_loaded") a, b, c, d = load_data(path) cls.basemodels_preds = a cls.train_y = b cls.test_preds = c cls.test_y = d __basemodels_score__(cls.basemodels_preds, cls.train_y)
self.w = w return w def test(self, x, y): y_pred = [] for x_i in x: temp = self.sigmoid(np.dot(x_i, self.w)) temp = 1 if temp >= 0.5 else 0 y_pred.append(temp) print accuracy_score(y_test, y_pred) print classification_report(y, y_pred) if __name__ == '__main__': x, y = load_data() x_train, y_train, x_test, y_test = x[:80], y[:80], x[80:], y[80:] lr = LR() lr.fit(x_train, y_train, 20) lr.test(x_test, y_test) """ 效果是0.6, sklearn可以做到100%.不得不服 from sklearn.linear_model import LogisticRegression lr = LogisticRegression() lr.fit(x_train, y_train) y_pred = lr.predict(x_test) print accuracy_score(y_test, y_pred) """
def test_fc(): data = ld.load_data() tdata = fc.feature_creation(data) assert len(tdata.columns) == 74
def main(config): """ Main training function """ print(f'Running experiment with arguments:\n{config}') base_experiment_directory = os.path.join('results', config.experiment_name) if not os.path.exists(base_experiment_directory): os.makedirs(base_experiment_directory) if config.seed is not None: torch.manual_seed(config.seed) torch.backends.cudnn.deterministic = True if config.evaluate and not config.resume: raise ValueError( 'Can only evaluate from a given checkpoint, use "resume" param') if config.share_weights and config.adversarial_model: raise ValueError( 'When sharing weights, only the localizer needs to be set') # Load data train_loader = load_data('train', config.dataset_root, config.img_resolution, config.batch_size, config.download_dataset) val_batch_size = 1 if config.evaluate else config.batch_size validation_loader = load_data('val', config.dataset_root, config.img_resolution, val_batch_size) print( f'Training set size: {len(train_loader.dataset)}, validation set size: {len(validation_loader.dataset)}' ) localizer = load_localizer(config.localizer_model, not config.localizer_from_scratch, config.attention_type, NUM_CLASSES) if torch.cuda.is_available(): localizer = localizer.cuda() localizer_optimizer = load_optimizer(config.optimizer, localizer.parameters(), config.learning_rate) if config.adversarial_model: adversarial = load_adversarial(config.adversarial_model, not config.adversarial_from_scratch, NUM_CLASSES) if torch.cuda.is_available(): adversarial = adversarial.cuda() adversarial_optimizer = load_optimizer( config.adversarial_optimizer, adversarial.parameters(), config.adversarial_learning_rate) else: adversarial = None adversarial_optimizer = None train_steps = (config.train_steps_localizer, config.train_steps_adversarial) training_phase = TrainingPhase(localizer, adversarial, len(train_loader), train_steps) start_epoch = 1 # Load weights (from checkpoint) if config.resume: if not os.path.isfile(config.resume): raise Exception(f'Given checkpoint {config.resume} is not a file') checkpoint = torch.load(config.resume) localizer.load_state_dict(checkpoint['localizer']) localizer_optimizer.load_state_dict(checkpoint['localizer_optimizer']) adversarial.load_state_dict(checkpoint['adversarial']) adversarial_optimizer.load_state_dict( checkpoint['adversarial_optimizer']) start_epoch = checkpoint['epoch'] + 1 if config.evaluate: print(f'Evaluating with weights from epoch {start_epoch - 1}') experiment_directory = os.path.join(base_experiment_directory, str(start_epoch)) if not os.path.exists(experiment_directory): os.makedirs(experiment_directory) validate(localizer, adversarial, validation_loader, experiment_directory, LABELS, config.segmentation_map_threshold, NUM_CLASSES, evaluate=True, save_results=True) return for epoch in range(start_epoch, config.epochs + 1): experiment_directory = os.path.join(base_experiment_directory, str(epoch)) if not os.path.exists(experiment_directory): os.makedirs(experiment_directory) print(f'Epoch: {epoch}/{config.epochs}') save_results = epoch % 3 == 0 # Save results (heatmaps, masks) every 3 epochs localizer.train() if adversarial is not None: adversarial.train() train(localizer, adversarial, localizer_optimizer, adversarial_optimizer, train_loader, epoch, config.alpha, config.beta, training_phase, config.share_weights) localizer.eval() if adversarial is not None: adversarial.eval() validate(localizer, adversarial, validation_loader, experiment_directory, LABELS, config.segmentation_map_threshold, NUM_CLASSES, save_results=save_results) # Save checkpoint state = { 'epoch': epoch, 'localizer': localizer.state_dict(), 'localizer_optimizer': localizer_optimizer.state_dict(), 'adversarial': adversarial.state_dict() if adversarial is not None else None, 'adversarial_optimizer': adversarial_optimizer.state_dict() if adversarial_optimizer is not None else None } save_location = os.path.join(base_experiment_directory, 'checkpoint.pth.tar') torch.save(state, save_location)
def main(): print('Loss & Optimizer') if args.loss == 'triplet': args.triplet = True criterion = TripletLoss(margin=args.margin, swap=args.swap) elif args.loss == 'triplet_distance': args.triplet = True criterion = TripletLoss(margin=args.margin, swap=args.swap, dist=True) else: args.triplet = False criterion = ContrastiveLoss(margin=args.margin) print('Prepare data') train_loader, valid_loader, valid_gallery_loader, test_loader, test_gallery_loader, in_size = load_data( args.dataset, args.data_path, triplet=args.triplet, batch_size=args.batch_size, prefetch=args.prefetch, set_partition=args.set_partition) print('Create model') if args.model == 'GAT': net = models.GNN_GAT(in_size, args.hidden, args.out_size, dropout=args.dropout) elif args.model == 'GRU': net = models.GNN_GRU(in_size, args.hidden, args.out_size, dropout=args.dropout) distNet = distance.SoftHd(args.out_size) optimizer = torch.optim.Adam(list(net.parameters()) + list(distNet.parameters()), args.learning_rate, weight_decay=args.decay) scheduler = StepLR(optimizer, 5, gamma=args.gamma) print('Check 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') net, distNet = net.cuda(), distNet.cuda() criterion = criterion.cuda() start_epoch = 0 best_perf = 0 early_stop_counter = 0 if args.load is not None: print('Loading model') checkpoint = load_checkpoint(args.load) net.load_state_dict(checkpoint['state_dict']) distNet.load_state_dict(checkpoint['state_dict_dist']) start_epoch = checkpoint['epoch'] best_perf = checkpoint['best_perf'] if not args.test: print('***Train***') for epoch in range(start_epoch, args.epochs): loss_train = train(train_loader, [net, distNet], optimizer, args.cuda, criterion, epoch) acc_valid, map_valid = test(valid_loader, valid_gallery_loader, [net, distNet], args.cuda, validation=True) # Early-Stop + Save model if map_valid.avg > best_perf: best_perf = map_valid.avg early_stop_counter = 0 if args.save is not None: save_checkpoint( { 'epoch': epoch + 1, 'state_dict': net.state_dict(), 'state_dict_dist': distNet.state_dict(), 'best_perf': best_perf }, directory=args.save, file_name='checkpoint') else: if early_stop_counter >= args.early_stop: print('Early Stop epoch {}'.format(epoch)) break early_stop_counter += 1 # Logger if args.log: # Scalars logger.add_scalar('loss_train', loss_train.avg) logger.add_scalar('acc_valid', acc_valid.avg) logger.add_scalar('map_valid', map_valid.avg) logger.add_scalar('learning_rate', scheduler.get_lr()[0]) logger.step() scheduler.step() # Load Best model in case of save it if args.save is not None: print('Loading best model') best_model_file = os.path.join(args.save, 'checkpoint.pth') checkpoint = load_checkpoint(best_model_file) net.load_state_dict(checkpoint['state_dict']) distNet.load_state_dict(checkpoint['state_dict_dist']) print('Best model at epoch {epoch} and acc {acc}%'.format( epoch=checkpoint['epoch'], acc=checkpoint['best_perf'])) print('***Valid***') test(valid_loader, valid_gallery_loader, [net, distNet], args.cuda) print('***Test***') test(test_loader, test_gallery_loader, [net, distNet], args.cuda) sys.exit()
def main(args): # Step 1: init data folders '''if os.path.exists('save_state/'+args.regime+'/normalization_stats.pkl'): print('Loading normalization stats') x_mean, x_sd = misc.load_file('save_state/'+args.regime+'/normalization_stats.pkl') else: x_mean, x_sd = preprocess.save_normalization_stats(args.regime) print('x_mean: %.3f, x_sd: %.3f' % (x_mean, x_sd))''' val_loader=load_data(args, "val") tb=TensorBoard(args.model_dir) # Step 2: init neural networks print("network is:",args.net) if args.net == 'Reab3p16': model = Reab3p16(args) elif args.net=='RN_mlp': model =WildRelationNet() if args.gpunum > 1: model = nn.DataParallel(model, device_ids=range(args.gpunum)) weights_path = args.path_weight+"/"+args.load_weight if os.path.exists(weights_path) and args.restore: pretrained_dict = torch.load(weights_path) model_dict = model.state_dict() pretrained_dict1 = {} for k, v in pretrained_dict.items(): if k in model_dict: pretrained_dict1[k] = v #print(k) model_dict.update(pretrained_dict1) model.load_state_dict(model_dict) print('load weight') style_raven={65:0, 129:1, 257:2, 66:3, 132:4, 36:5, 258:6, 136:7, 264:8, 72:9, 130:10 , 260:11, 40:12, 34:13, 49:14, 18:15, 20:16, 24:17} model.cuda() optimizer = optim.SGD(model.parameters(), lr=args.lr,momentum=args.mo, weight_decay=5e-4) if args.gpunum>1: optimizer = nn.DataParallel(optimizer, device_ids=range(args.gpunum)) iter_count = 1 epoch_count = 1 #iter_epoch=int(len(train_files) / args.batch_size) print(time.strftime('%H:%M:%S', time.localtime(time.time())), 'training') style_raven_len = len(style_raven) if args.rl_style=="dqn": dqn = DQN() elif args.rl_style=="ddpg": ram = MemoryBuffer(1000) ddpg = Trainer(style_raven_len*4+2, style_raven_len, 1, ram) alpha_1=0.1 if args.rl_style=="dqn": a = dqn.choose_action([0.5] * 3) # TODO elif args.rl_style=="ddpg": action_ = ddpg.get_exploration_action(np.zeros([style_raven_len*4+2]).astype(np.float32),alpha_1) if args.type_loss:loss_fn=nn.BCELoss() best_acc=0.0 while True: since=time.time() print(action_) for i in range(style_raven_len): tb.scalar_summary("action/a"+str(i), action_[i], epoch_count) data_files = preprocess.provide_data(args.regime, style_raven_len, action_,style_raven) train_files = [data_file for data_file in data_files if 'train' in data_file] print("train_num:", len(train_files)) train_loader = torch.utils.data.DataLoader(Dataset(args,train_files), batch_size=args.batch_size, shuffle=True, num_workers=args.numwork) model.train() iter_epoch = int(len(train_files) / args.batch_size) acc_part_train=np.zeros([style_raven_len,2]).astype(np.float32) mean_loss_train= np.zeros([style_raven_len, 2]).astype(np.float32) loss_train=0 for x, y,style,me in train_loader: if x.shape[0]<10: print(x.shape[0]) break x, y ,meta = Variable(x).cuda(), Variable(y).cuda(), Variable(me).cuda() if args.gpunum > 1: optimizer.module.zero_grad() else: optimizer.zero_grad() if args.type_loss: pred_train, pred_meta= model(x) else: pred_train = model(x) loss_ = F.nll_loss(pred_train, y,reduce=False) loss=loss_.mean() if not args.type_loss else loss_.mean()+10*loss_fn(pred_meta,meta) loss.backward() if args.gpunum > 1: optimizer.module.step() else: optimizer.step() iter_count += 1 pred = pred_train.data.max(1)[1] correct = pred.eq(y.data).cpu() loss_train+=loss.item() for num, style_pers in enumerate(style): style_pers = style_pers[:-4].split("/")[-1].split("_")[3:] for style_per in style_pers: style_per=int(style_per) if correct[num] == 1: acc_part_train[style_per, 0] += 1 acc_part_train[style_per, 1] += 1 #mean_pred_train[style_per,0] += pred_train[num,y[num].item()].data.cpu() #mean_pred_train[style_per, 1] += 1 mean_loss_train[style_per,0] += loss_[num].item() mean_loss_train[style_per, 1] += 1 accuracy_total = correct.sum() * 100.0 / len(y) if iter_count %10 == 0: iter_c = iter_count % iter_epoch print(time.strftime('%H:%M:%S', time.localtime(time.time())), ('train_epoch:%d,iter_count:%d/%d, loss:%.3f, acc:%.1f') % ( epoch_count, iter_c, iter_epoch, loss, accuracy_total)) tb.scalar_summary("train_loss",loss,iter_count) loss_train=loss_train/len(train_files) #mean_pred_train=[x[0]/ x[1] for x in mean_pred_train] mean_loss_train=[x[0]/ x[1] for x in mean_loss_train] acc_part_train = [x[0] / x[1] if x[1]!=0 else 0 for x in acc_part_train] print(acc_part_train) if epoch_count %args.lr_step ==0: print("change lr") adjust_learning_rate(optimizer, epoch_count, args.lr_step,args.gpunum) time_elapsed = time.time() - since print('train epoch in {:.0f}h {:.0f}m {:.0f}s'.format( time_elapsed // 3600, time_elapsed // 60 % 60, time_elapsed % 60)) #acc_p=np.array([x[0]/x[1] for x in acc_part]) #print(acc_p) with torch.no_grad(): model.eval() accuracy_all = [] iter_test=0 acc_part_val = np.zeros([style_raven_len, 2]).astype(np.float32) for x, y, style,me in val_loader: iter_test+=1 x, y = Variable(x).cuda(), Variable(y).cuda() pred,_ = model(x) pred = pred.data.max(1)[1] correct = pred.eq(y.data).cpu().numpy() accuracy = correct.sum() * 100.0 / len(y) for num, style_pers in enumerate(style): style_pers = style_pers[:-4].split("/")[-1].split("_")[3:] for style_per in style_pers: style_per = int(style_per) if correct[num] == 1: acc_part_val[style_per, 0] += 1 acc_part_val[style_per, 1] += 1 accuracy_all.append(accuracy) # if iter_test % 10 == 0: # # print(time.strftime('%H:%M:%S', time.localtime(time.time())), # ('test_iter:%d, acc:%.1f') % ( # iter_test, accuracy)) accuracy_all = sum(accuracy_all) / len(accuracy_all) acc_part_val = [x[0] / x[1] if x[1]!=0 else 0 for x in acc_part_val ] baseline_rl=70 reward=np.mean(acc_part_val)*100-baseline_rl tb.scalar_summary("valreward", reward,epoch_count) action_list=[x for x in a] cur_state=np.array(acc_part_val+acc_part_train+action_list+mean_loss_train +[loss_train]+[epoch_count]).astype(np.float32) #np.expand_dims(, axis=0) if args.rl_style == "dqn": a = dqn.choose_action(cur_state) # TODO elif args.rl_style == "ddpg": a = ddpg.get_exploration_action(cur_state,alpha_1) if alpha_1<1: alpha_1+=0.005#0.1 if epoch_count > 1: if args.rl_style == "dqn":dqn.store_transition(last_state, a, reward , cur_state) elif args.rl_style == "ddpg":ram.add(last_state, a, reward, cur_state) if epoch_count > 1: if args.rl_style == "dqn":dqn.learn() elif args.rl_style == "ddpg":loss_actor, loss_critic=ddpg.optimize() print('------------------------------------') print('learn q learning') print('------------------------------------') tb.scalar_summary("loss_actor", loss_actor, epoch_count) tb.scalar_summary("loss_critic", loss_critic, epoch_count) last_state=cur_state time_elapsed = time.time() - since print('test epoch in {:.0f}h {:.0f}m {:.0f}s'.format( time_elapsed // 3600, time_elapsed // 60 % 60, time_elapsed % 60)) print('------------------------------------') print(('epoch:%d, acc:%.1f') % (epoch_count, accuracy_all)) print('------------------------------------') if accuracy_all>best_acc: best_acc=max(best_acc,accuracy_all) #ddpg.save_models(args.model_dir + '/', epoch_count) save_state(model.state_dict(), args.model_dir + "/epochbest") epoch_count += 1 if epoch_count%20==0: print("save weights") ddpg.save_models(args.model_dir+'/',epoch_count ) save_state(model.state_dict(), args.model_dir+"/epoch"+str(epoch_count))
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) eval_type = FLAGS.eval_type imagenet_pretrained = FLAGS.imagenet_pretrained NUM_CLASSES = 400 if eval_type == 'rgb600': NUM_CLASSES = 600 if eval_type not in ['rgb', 'rgb600', 'flow', 'joint']: raise ValueError('Bad `eval_type`, must be one of rgb, rgb600, flow, joint') if eval_type == 'rgb600': kinetics_classes = [x.strip() for x in open(_LABEL_MAP_PATH_600)] else: kinetics_classes = [x.strip() for x in open(_LABEL_MAP_PATH)] if eval_type in ['rgb', 'rgb600', 'joint']: # RGB input has 3 channels. rgb_input = tf.placeholder( tf.float32, shape=(1, _SAMPLE_VIDEO_FRAMES, _IMAGE_SIZE, _IMAGE_SIZE, 3)) with tf.variable_scope('RGB'): rgb_model = i3d.InceptionI3d( NUM_CLASSES, spatial_squeeze=True, final_endpoint='Logits') rgb_logits, _ = rgb_model( rgb_input, is_training=False, dropout_keep_prob=1.0) rgb_variable_map = {} for variable in tf.global_variables(): if variable.name.split('/')[0] == 'RGB': if eval_type == 'rgb600': rgb_variable_map[variable.name.replace(':0', '')[len('RGB/inception_i3d/'):]] = variable else: rgb_variable_map[variable.name.replace(':0', '')] = variable rgb_saver = tf.train.Saver(var_list=rgb_variable_map, reshape=True) if eval_type in ['flow', 'joint']: # Flow input has only 2 channels. flow_input = tf.placeholder( tf.float32, shape=(1, _SAMPLE_VIDEO_FRAMES, _IMAGE_SIZE, _IMAGE_SIZE, 2)) with tf.variable_scope('Flow'): flow_model = i3d.InceptionI3d( NUM_CLASSES, spatial_squeeze=True, final_endpoint='Logits') flow_logits, _ = flow_model( flow_input, is_training=False, dropout_keep_prob=1.0) flow_variable_map = {} for variable in tf.global_variables(): if variable.name.split('/')[0] == 'Flow': flow_variable_map[variable.name.replace(':0', '')] = variable flow_saver = tf.train.Saver(var_list=flow_variable_map, reshape=True) if eval_type == 'rgb' or eval_type == 'rgb600': model_logits = rgb_logits elif eval_type == 'flow': model_logits = flow_logits else: model_logits = rgb_logits + flow_logits model_predictions = tf.nn.softmax(model_logits) with tf.Session() as sess: feed_dict = {} if eval_type in ['rgb', 'rgb600', 'joint']: if imagenet_pretrained: rgb_saver.restore(sess, _CHECKPOINT_PATHS['rgb_imagenet']) else: rgb_saver.restore(sess, _CHECKPOINT_PATHS[eval_type]) tf.logging.info('RGB checkpoint restored') sample_pool = os.listdir(_SAMPLE_ROOT_) sample_pool.sort() results = [] for vid_name in tqdm(sample_pool): rgb_sample = load_data(os.path.join(_SAMPLE_ROOT_, vid_name)) #tf.logging.info('RGB data loaded, shape=%s', str(rgb_sample.shape)) feed_dict[rgb_input] = rgb_sample # if eval_type in ['flow', 'joint']: # if imagenet_pretrained: # flow_saver.restore(sess, _CHECKPOINT_PATHS['flow_imagenet']) # else: # flow_saver.restore(sess, _CHECKPOINT_PATHS['flow']) # tf.logging.info('Flow checkpoint restored') # flow_sample = np.load(_SAMPLE_PATHS['flow']) # tf.logging.info('Flow data loaded, shape=%s', str(flow_sample.shape)) # feed_dict[flow_input] = flow_sample out_logits, out_predictions = sess.run( [model_logits, model_predictions], feed_dict=feed_dict) out_logits = out_logits[0] out_predictions = out_predictions[0] results.append(out_predictions) plot_results(results, ap_num=4, full_range=360, grad=15, variable='ForTest', class_id=260) gt_labels = [260]*len(results) top1, top5 = top_k_accuracy(results, gt_labels, k=(1, 5)) print("Top-1 Accuracy = {:.02f}".format(top1 * 100)) print("Top-5 Accuracy = {:.02f}".format(top5 * 100))
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) eval_type = FLAGS.eval_type imagenet_pretrained = FLAGS.imagenet_pretrained NUM_CLASSES = 400 if eval_type == 'rgb600': NUM_CLASSES = 600 if eval_type not in ['rgb', 'rgb600', 'flow', 'joint']: raise ValueError('Bad `eval_type`, must be one of rgb, rgb600, flow, joint') if eval_type == 'rgb600': kinetics_classes = [x.strip() for x in open(_LABEL_MAP_PATH_600)] else: kinetics_classes = [x.strip() for x in open(_LABEL_MAP_PATH)] if eval_type in ['rgb', 'rgb600', 'joint']: # RGB input has 3 channels. rgb_input = tf.placeholder( tf.float32, shape=(1, _SAMPLE_VIDEO_FRAMES, _IMAGE_SIZE, _IMAGE_SIZE, 3)) with tf.variable_scope('RGB'): rgb_model = i3d.InceptionI3d( NUM_CLASSES, spatial_squeeze=True, final_endpoint='Logits') rgb_logits, _ = rgb_model( rgb_input, is_training=False, dropout_keep_prob=1.0) rgb_variable_map = {} for variable in tf.global_variables(): if variable.name.split('/')[0] == 'RGB': if eval_type == 'rgb600': rgb_variable_map[variable.name.replace(':0', '')[len('RGB/inception_i3d/'):]] = variable else: rgb_variable_map[variable.name.replace(':0', '')] = variable rgb_saver = tf.train.Saver(var_list=rgb_variable_map, reshape=True) if eval_type in ['flow', 'joint']: # Flow input has only 2 channels. flow_input = tf.placeholder( tf.float32, shape=(1, _SAMPLE_VIDEO_FRAMES, _IMAGE_SIZE, _IMAGE_SIZE, 2)) with tf.variable_scope('Flow'): flow_model = i3d.InceptionI3d( NUM_CLASSES, spatial_squeeze=True, final_endpoint='Logits') flow_logits, _ = flow_model( flow_input, is_training=False, dropout_keep_prob=1.0) flow_variable_map = {} for variable in tf.global_variables(): if variable.name.split('/')[0] == 'Flow': flow_variable_map[variable.name.replace(':0', '')] = variable flow_saver = tf.train.Saver(var_list=flow_variable_map, reshape=True) if eval_type == 'rgb' or eval_type == 'rgb600': model_logits = rgb_logits elif eval_type == 'flow': model_logits = flow_logits else: model_logits = rgb_logits + flow_logits model_predictions = tf.nn.softmax(model_logits) csvFile = open('transfer_ucf101.csv', 'a') writer = csv.writer(csvFile) writer.writerow(['Actnames', 'Top-1 accuracy', 'Top-5 accuracy']) with tf.Session() as sess: feed_dict = {} if eval_type in ['rgb', 'rgb600', 'joint']: if imagenet_pretrained: rgb_saver.restore(sess, _CHECKPOINT_PATHS['rgb_imagenet']) else: rgb_saver.restore(sess, _CHECKPOINT_PATHS[eval_type]) tf.logging.info('RGB checkpoint restored') listfile = open(_TESTLIST_PATH_, 'r') testlist = listfile.readlines() actnames = [] gt_labels = [] results = [] for item in tqdm(testlist): sample = item.split('\n')[0] video_name = sample.split(' ')[0] video_label = int(sample.split(' ')[1]) class_name = video_name.split('/')[0] gt_labels.append(video_label) actnames.append(class_name) rgb_sample = load_data(os.path.join(_SAMPLE_ROOT_, video_name)) #tf.logging.info('RGB data loaded, shape=%s', str(rgb_sample.shape)) feed_dict[rgb_input] = rgb_sample out_logits, out_predictions = sess.run( [model_logits, model_predictions], feed_dict=feed_dict) #out_logits = out_logits[0] out_predictions = out_predictions[0] results.append(out_predictions) assert len(results) % _VIDS_PER_CLASS_ == 0 class_num = len(results) // _VIDS_PER_CLASS_ for idx in range(0, class_num): preds = results[idx*_VIDS_PER_CLASS_ : (idx+1)*_VIDS_PER_CLASS_] labels = gt_labels[idx*_VIDS_PER_CLASS_ : (idx+1)*_VIDS_PER_CLASS_] top1, top5 = top_k_accuracy(preds, labels, k=(1, 5)) row = [actnames[idx*_VIDS_PER_CLASS_], "{:.4f}".format(top1), "{:.4f}".format(top5)] writer.writerow(row) csvFile.close()
input_size = 28 * 28 output_size = 10 elif name_dataset == "diabetes": modelname = "natural_5" modelname_pgd = "pgd_5" batch_size_train = 10 batch_size_test = 10 test_size_abs = 77 hidden_layers = [20, 20] hist = False hist_str = "_hist" if hist else "" dataset = load_data(name_dataset) #Normalize data between 0-1 atts = dataset.columns[0:dataset.shape[1] - 1] dataset[atts] = preprocessing.normalize(dataset[atts]) if os.path.isfile("../data/splits/" + name_dataset + "_trainsplit.pkl"): print("Split loading") with open("../data/splits/" + name_dataset + "_trainsplit.pkl", 'rb') as f: train = pickle.load(f) with open("../data/splits/" + name_dataset + "_testsplit.pkl", 'rb') as f: test = pickle.load(f) else: train, test = train_test_split(dataset,
def main(): print('Prepare data') train_loader, valid_loader, valid_gallery_loader, test_loader, test_gallery_loader, in_size = load_data( args.dataset, args.data_path, batch_size=args.batch_size, prefetch=args.prefetch, set_partition=args.set_partition) distance = realdistance.HausdorffEditDistance(alpha=args.alpha, beta=args.beta, tau_n=args.tau_n, tau_e=args.tau_e) print('Check CUDA') if args.cuda and args.ngpu > 1: distance = torch.nn.DataParallel(distance, device_ids=list(range(args.ngpu))) if args.cuda: distance = distance.cuda() print('***Test***') test(test_loader, test_gallery_loader, distance, args.cuda)
def run_tpot_idn_optimization(gens, pop_size, max_time_mins, sample, sample_size, export_best_pipeline=True): # Initiate logging - overwrite existing log file if exists logging.basicConfig(filename="tpot_idn_pipeline.log", level=logging.INFO, filemode='w') # Load and transform the training data X_train, y_train, w_train = load_data(TRAIN_PATH) # Load and transform the test data X_test, y_test, w_test = load_data(TEST_PATH) logging.info("Train and test data loaded") orig_index = X_train.index # Reduce training set if testing sample if sample: orig_train_size = X_train.shape[0] X_train = (X_train.reset_index() .sample(sample_size, random_state=0) .set_index('hid')) logging.info(f"Training samples reduced from {orig_train_size} to {X_train.shape[0]}") # Assert consistency before training assert X_train.shape[1] == X_test.shape[1] # Enforce consistency between features and labels y_train = pd.DataFrame(y_train, index=orig_index).loc[X_train.index] y_train = np.ravel(y_train.values) if max_time_mins is not None: max_time_mins = int(max_time_mins) # Instantiate tpot classifier logging.info("Instantiating classifier") tpot = TPOTClassifier(generations=gens, population_size=pop_size, max_time_mins=max_time_mins, scoring='f1', verbosity=2, n_jobs=-1, # memory='auto', random_state=2017, # early_stop=6, subsample=0.5) # Fit the classifier start_time = time.strftime('%a, %d %b %Y %H:%M:%S', time.localtime()) logging.info(f"Fitting classifier:\t\t{start_time}") tpot.fit(X_train, y_train, w_train) end_time = time.strftime('%a, %d %b %Y %H:%M:%S', time.localtime()) logging.info(f"Fitting complete:\t\t{end_time}") # Export the pipeline logging.info("Exporting best pipeline...") if export_best_pipeline: tpot.export('tpot_idn_pipeline.py') # Record f1 score on test set logging.info(f"Test f1 score:\t{tpot.score(X_test, y_test)}")
def setUpGlobal(cls): a, b, c, d = load_data("./data/datasets/75191") cls.basemodels_preds = a cls.train_y = b cls.test_preds = c cls.test_y = d
def run(): torch.multiprocessing.freeze_support() device = torch.device('cpu') weights_path = "C:\\Users\\Hertz\\Documents\\SJSU Coursework\\MS Project_big files\\git\\distracting_feature\\distracting_feature\\epochs\\epoch860" weights_path = "C:\\Users\\Hertz\\Documents\\SJSU Coursework\\MS Project_big files\\git\\distracting_feature\\distracting_feature\\epochs\\epoch860" # got ~20 percent here. weights_path = "C:\\Users\\Hertz\\Documents\\SJSU Coursework\\MS Project_big files\\git\\distracting_feature\\distracting_feature\\epochs\\epochbest(73.6)" #model_path = "C:\\Users\\Hertz\\Documents\\SJSU Coursework\\MS Project_big files\\git\\distracting_feature\\distracting_feature\\epochs\\epoch860" # got ~70 percent here. #image_path = "C:\\Users\\sonam\\Desktop\\MS_Project\\test_model\\RAVEN_1368_test\\image.npy" # image_path = os.path.join(RAVEN_folder, file_folder) # image_path = str(RAVEN_folder)+"/"+ str(file) # image_path = "C:/Users/Hertz/Documents/SJSU Coursework/MS Project_big files/RAVEN-10000-release/RAVEN-10000/center_single/RAVEN_10_train.npz" image_path = "C:/Users/Hertz/Documents/SJSU Coursework/MS Project_big files/RAVEN-10000-release/RAVEN-10000/" ap = argparse.ArgumentParser() #ap.add_argument("type_loss", type=bool) #ap.add_argument("image_path", type=str) ap.add_argument('--type_loss', type=bool, default=True) ap.add_argument('--image_path', type=str, default=image_path) ap.add_argument('--regime', type=str, default='all') ap.add_argument('--image_type', type=str, default='image') ap.add_argument('--batch_size', type=int, default=1) ap.add_argument('--numwork', dest='numwork', type=int, default=1) args = ap.parse_args() # args = config.get_args() # args = args[0] # weights_path = args.path_weight+"/"+args.load_weight pretrained_dict = torch.load(weights_path, map_location=device) # print("pretrained_dict:", pretrained_dict) r_model = m.Reab3p16(args) model_dict = r_model.state_dict( ) ## https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.htmlA state_dict is an integral entity pretrained_dict1 = { } ##..if you are interested in saving or loading models from PyTorch for k, v in pretrained_dict.items(): ##filter out unnecessary keys k if k[:7] == "module.": k = k[7:] if k in model_dict: ##only when keys match(like conv2D..and so forth) pretrained_dict1[k] = v print(k) model_dict.update( pretrained_dict1) ##overwrite entries in the existing state dict r_model.load_state_dict(model_dict) # print("pretrained_dict1:", pretrained_dict1) with torch.no_grad(): r_model.eval() accuracy_all = [] #data_dir = "C:/Users/Hertz/Documents/SJSU Coursework/MS Project_big files/RAVEN-10000-release/RAVEN-10000/" data_dir = "C:/Users/Hertz/Documents/SJSU Coursework/MS Project_big files/RAVEN 1000/" loader_try = load_data(args, "train", data_dir) # print(loader_try) # data_split = "train" # data_files = [image_path] # print("datafiles: ", data_files) # df = [data_file for data_file in data_files][:] # print("df: ", df) loader = torch.utils.data.DataLoader(Dataset(args, loader_try), batch_size=args.batch_size, num_workers=args.numwork) # checkpoint = torch.load(model_path, map_location=device) count = 0 for x, y, style, me in loader_try: count = count + 1 #print("count", count) # print("style:", style) x, y = Variable(x), Variable(y) pred = r_model(x) # print("pred:", pred) pred = pred[0].data.max(1)[1] # print("pred:", pred) # print("y",y) correct = pred.eq(y.data).cpu().numpy() accuracy = correct.sum() * 100.0 / len(y) print("accuracy", accuracy) accuracy_all.append(accuracy) accuracy_all = sum(accuracy_all) / len(accuracy_all) print(accuracy_all)
help="Input text file") parser.add_argument("-w", "--weights", action="store", required=False, dest="weights", help="Model weights path") parser.add_argument("-i", "--input", action="store", required=False, dest="input", help="Input string for complete") parser.add_argument("-o", "--out_len", action="store", required=False, dest="out_len", help="Out length") args = parser.parse_args() _, _, vectorizer = load_data.load_data(args.text, False, False, False, 1) model = model.make_text_generator_model(1, vectorizer.vocab_size) model.load_weights(args.weights) res = generate(model, vectorizer, seed=args.input, length=int(args.out_len)) print(res)
parser.add_argument("-v", "--validaion_rate", action="store", required=False, dest="validaion_rate", help="Rate validation data") args = parser.parse_args() if args.batch_size is not None: config.batch_size = int(args.batch_size) if args.epochs is not None: config.num_epochs = int(args.epochs) if args.use_words is not None: config.use_words = bool(args.use_words) if args.save_path is not None: config.save_path = args.save_path if args.validaion_rate is not None: config.validation_rate = args.validation_rate x_train, y_train, vectorizer = load_data.load_data(args.text, config.use_words, False, False, config.batch_size, config.seq_length) generator = model.make_text_generator_model( batch_size=config.batch_size, vocab_size=vectorizer.vocab_size) train(generator, x_train, y_train)
def main(args): # Step 1: init data folders '''if os.path.exists('save_state/'+args.regime+'/normalization_stats.pkl'): ##to load raw data and preprocess it print('Loading normalization stats') x_mean, x_sd = misc.load_file('save_state/'+args.regime+'/normalization_stats.pkl') else: x_mean, x_sd = preprocess.save_normalization_stats(args.regime) print('x_mean: %.3f, x_sd: %.3f' % (x_mean, x_sd))''' val_loader=load_data(args, "val") ##loading already preprocessed validation/testing data tb=TensorBoard(args.model_dir) ##The model_dir arguments represents the directory to save model parameters, graph and etc. This can also be used to ##load checkpoints from the directory into a estimator to continue training a previously saved model. # Step 2: init neural networks print("network is:",args.net) if args.net == 'Reab3p16': ##if want to use model Reab3p16 model = Reab3p16(args) elif args.net=='RN_mlp': ##if want to use model WildRelationNet model =WildRelationNet() if args.gpunum > 1: model = nn.DataParallel(model, device_ids=range(args.gpunum)) ##The nn package defines a set of Modules, which you can think of as a neural network layer that has produces output from ##input and may have some trainable weights. ##when more than one gpu, want to save model weights using DataParrallel module prefix weights_path = args.path_weight+"/"+args.load_weight ##saved weigths of model if os.path.exists(weights_path) and args.restore: ##pretrained weights pretrained_dict = torch.load(weights_path) ##pretrained_dict is the state dictionary of the pre-trained model available model_dict = model.state_dict() ## https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.htmlA state_dict is an integral entity pretrained_dict1 = {} ##..if you are interested in saving or loading models from PyTorch for k, v in pretrained_dict.items(): ##filter out unnecessary keys k if k in model_dict: ##only when keys match(like conv2D..and so forth) pretrained_dict1[k] = v #print(k) model_dict.update(pretrained_dict1) ##overwrite entries in the existing state dict model.load_state_dict(model_dict) ##load the new state dict, new weights print('load weight') style_raven={65:0, 129:1, 257:2, 66:3, 132:4, 36:5, 258:6, 136:7, 264:8, 72:9, 130:10 ##dictionary(key:value pair of , 260:11, 40:12, 34:13, 49:14, 18:15, 20:16, 24:17} ##After setting weights using optimizer for training. ##The standard way in PyTorch to train a model in multiple GPUs is to use nn.DataParallel which copies the model to the GPUs ##and during training splits the batch among them and combines the individual outputs. ##model.cuda() by default will send your model to the "current device" #If you need to move a model to GPU via .cuda(), please do so before constructing optimizers for it. Parameters of a model #after .cuda() will be different objects with those before the call. ##A very popular technique that is used along with SGD is called Momentum. Instead of using only the gradient of the current ##step to guide the search, momentum also accumulates the gradient of the past steps to determine the direction to go model.cuda() optimizer = optim.SGD(model.parameters(), lr=args.lr,momentum=args.mo, weight_decay=5e-4) ##Adam has convergence problems that often SGD + momentum can converge better ##with longer training time. We often see a lot of papers in 2018 and 2019 were still using SGD if args.gpunum>1: optimizer = nn.DataParallel(optimizer, device_ids=range(args.gpunum)) ##setting iter-count and epoch to 1 before starting training iter_count = 1 ## number of batches of data the algorithm has seen (or simply the number of passes the algorithm has done on the dataset) epoch_count = 1 ##number of times a learning algorithm sees the complete dataset #iter_epoch=int(len(train_files) / args.batch_size) print(time.strftime('%H:%M:%S', time.localtime(time.time())), 'training') style_raven_len = len(style_raven) ##length of style raven dict if args.rl_style=="dqn": ##calling reinforcemt model for training dqn = DQN() ##if want to use dqn model elif args.rl_style=="ddpg": ##if want to use ddpg model (aiming to use this) ram = MemoryBuffer(1000) ddpg = Trainer(style_raven_len*4+2, style_raven_len, 1, ram) ##creating an instance of Trainer class defined in rl folder (ddpg.py) why style_raven_len*4+2? alpha_1=0.1 if args.rl_style=="dqn": a = dqn.choose_action([0.5] * 3) # TODO elif args.rl_style=="ddpg": action_ = ddpg.get_exploration_action(np.zeros([style_raven_len*4+2]).astype(np.float32),alpha_1) ##calling exploration which returns action? if args.type_loss:loss_fn=nn.BCELoss() ##Creates a criterion that measures the Binary Cross Entropy between the target and the output. best_acc=0.0 ##setting accuracy to 0.0 while True: ##loop(train) until since=time.time() print(action_) for i in range(style_raven_len): tb.scalar_summary("action/a"+str(i), action_[i], epoch_count) ##saving summary such as poch counts and actions data_files = preprocess.provide_data(args.regime, style_raven_len, action_,style_raven) train_files = [data_file for data_file in data_files if 'train' in data_file] #creating a list of training files print("train_num:", len(train_files)) ##torch.utils.data.DataLoader` supports both map-style and iterable-style datasets with single- or multi-process loading, ##customizing loading order and optional automatic batching (collation) and memory pinning ##shuffle true because we want independent B training batches from Dataset train_loader = torch.utils.data.DataLoader(Dataset(args,train_files), batch_size=args.batch_size, shuffle=True, num_workers=args.numwork) model.train() ##start training model iter_epoch = int(len(train_files) / args.batch_size) ##setting iteration count for total dataset acc_part_train=np.zeros([style_raven_len,2]).astype(np.float32) ##defining variable for saving part accuracy while training mean_loss_train= np.zeros([style_raven_len, 2]).astype(np.float32) ##defining variable for saving mean loss while training loss_train=0 for x, y,style,me in train_loader: if x.shape[0]<10: ##x.shape[0] will give the number of rows in an array (10 by 1024 2D array) print(x.shape[0]) break x, y ,meta = Variable(x).cuda(), Variable(y).cuda(), Variable(me).cuda() ##Components are accessible as variable.x, variable.y, variable.z if args.gpunum > 1: optimizer.module.zero_grad() ##to set the gradient of the parameters in the model to 0, module beacause DataParallel else: optimizer.zero_grad() ## same as above set the gradient of the parameters to zero if args.type_loss: pred_train, pred_meta= model(x) ##applying model to x where x is from training data else: pred_train = model(x) ##x is images y is actual label/category loss_ = F.nll_loss(pred_train, y,reduce=False) ##calculating loss occurred while training loss=loss_.mean() if not args.type_loss else loss_.mean()+10*loss_fn(pred_meta,meta)##If your loss is not a scalar value, then you should certainly use either loss.backward() ##loss.mean() or loss.sum() to convert it to a scalar before calling the backward. Otherwise, it will cause an error #When you call loss.backward(), all it does is compute gradient of loss w.r.t all the parameters in loss that have ##requires_grad = True and store them in parameter.grad attribute for every parameter. ##optimizer.step() updates all the parameters based on parameter.grad if args.gpunum > 1: optimizer.module.step() ##module for DataParallel else: optimizer.step() iter_count += 1 ##update iter-count by 1 evrytime pred = pred_train.data.max(1)[1] correct = pred.eq(y.data).cpu() ##compare actual and predicted category loss_train+=loss.item() ##The average of the batch losses will give you an estimate of the “epoch loss” during training. for num, style_pers in enumerate(style): style_pers = style_pers[:-4].split("/")[-1].split("_")[3:] for style_per in style_pers: style_per=int(style_per) if correct[num] == 1: acc_part_train[style_per, 0] += 1 acc_part_train[style_per, 1] += 1 #mean_pred_train[style_per,0] += pred_train[num,y[num].item()].data.cpu() #mean_pred_train[style_per, 1] += 1 mean_loss_train[style_per,0] += loss_[num].item() mean_loss_train[style_per, 1] += 1 accuracy_total = correct.sum() * 100.0 / len(y) ####calc accuracy if iter_count %10 == 0: ##do this for 10 iterations iter_c = iter_count % iter_epoch print(time.strftime('%H:%M:%S', time.localtime(time.time())), ('train_epoch:%d,iter_count:%d/%d, loss:%.3f, acc:%.1f') % ( epoch_count, iter_c, iter_epoch, loss, accuracy_total)) tb.scalar_summary("train_loss",loss,iter_count) ##saving train loss to summary loss_train=loss_train/len(train_files) ##The average of the batch losses will give you an estimate of the “epoch loss” during training. #mean_pred_train=[x[0]/ x[1] for x in mean_pred_train] mean_loss_train=[x[0]/ x[1] for x in mean_loss_train] acc_part_train = [x[0] / x[1] if x[1]!=0 else 0 for x in acc_part_train] print(acc_part_train) if epoch_count %args.lr_step ==0: ##adjusting learning rate after 30 epochs print("change lr") adjust_learning_rate(optimizer, epoch_count, args.lr_step,args.gpunum) time_elapsed = time.time() - since print('train epoch in {:.0f}h {:.0f}m {:.0f}s'.format( time_elapsed // 3600, time_elapsed // 60 % 60, time_elapsed % 60)) #acc_p=np.array([x[0]/x[1] for x in acc_part]) #print(acc_p) with torch.no_grad(): model.eval() ##evaluating model accuracy_all = [] iter_test=0 acc_part_val = np.zeros([style_raven_len, 2]).astype(np.float32) for x, y, style,me in val_loader: ##using validation data iter_test+=1 x, y = Variable(x).cuda(), Variable(y).cuda() pred,_ = model(x) pred = pred.data.max(1)[1] correct = pred.eq(y.data).cpu().numpy() accuracy = correct.sum() * 100.0 / len(y) ##accuracy is calc basd on how many labels match for num, style_pers in enumerate(style): style_pers = style_pers[:-4].split("/")[-1].split("_")[3:] for style_per in style_pers: style_per = int(style_per) if correct[num] == 1: acc_part_val[style_per, 0] += 1 acc_part_val[style_per, 1] += 1 accuracy_all.append(accuracy) ##append to accuracy list # if iter_test % 10 == 0: # # print(time.strftime('%H:%M:%S', time.localtime(time.time())), # ('test_iter:%d, acc:%.1f') % ( # iter_test, accuracy)) accuracy_all = sum(accuracy_all) / len(accuracy_all) ##total accuracy is calculated acc_part_val = [x[0] / x[1] if x[1]!=0 else 0 for x in acc_part_val ] baseline_rl=70 ##baseline for accuracy reward=np.mean(acc_part_val)*100-baseline_rl ##calculating reward using val accuracy tb.scalar_summary("valreward", reward,epoch_count) ##saving summary action_list=[x for x in a] cur_state=np.array(acc_part_val+acc_part_train+action_list+mean_loss_train ##saving all calc in currnt state +[loss_train]+[epoch_count]).astype(np.float32) #np.expand_dims(, axis=0) if args.rl_style == "dqn": a = dqn.choose_action(cur_state) # TODO elif args.rl_style == "ddpg": ##passing current state to rl model's get_exploration_action a = ddpg.get_exploration_action(cur_state,alpha_1) if alpha_1<1: alpha_1+=0.005#0.1 if epoch_count > 1: ##saving last state and current state ,reward in memory for epoch >1 if args.rl_style == "dqn":dqn.store_transition(last_state, a, reward , cur_state) elif args.rl_style == "ddpg":ram.add(last_state, a, reward, cur_state) if epoch_count > 1: if args.rl_style == "dqn":dqn.learn() elif args.rl_style == "ddpg":loss_actor, loss_critic=ddpg.optimize() ##using rl ddpg model's optimize function to for teaching print('------------------------------------') print('learn q learning') print('------------------------------------') tb.scalar_summary("loss_actor", loss_actor, epoch_count) tb.scalar_summary("loss_critic", loss_critic, epoch_count) last_state=cur_state time_elapsed = time.time() - since print('test epoch in {:.0f}h {:.0f}m {:.0f}s'.format( time_elapsed // 3600, time_elapsed // 60 % 60, time_elapsed % 60)) print('------------------------------------') print(('epoch:%d, acc:%.1f') % (epoch_count, accuracy_all)) print('------------------------------------') if accuracy_all>best_acc: ##save the best accuracy obtained from val data as best accuracy for next epoch best_acc=max(best_acc,accuracy_all) #ddpg.save_models(args.model_dir + '/', epoch_count) save_state(model.state_dict(), args.model_dir + "/epochbest") ##saving the current state epoch_count += 1 ##increasing epoch count by 1 if epoch_count%20==0: ##Do this for 20 epochs for complete dataset print("save weights") ddpg.save_models(args.model_dir+'/',epoch_count ) ##saving the model save_state(model.state_dict(), args.model_dir+"/epoch"+str(epoch_count))
import sys sys.path.append("../../") from data.load_data import (get_country_filepaths, split_features_labels_weights, load_data) from features.process_features import get_vif, standardize sys.path.append("../") from evaluation import calculate_metrics, evaluate_model COUNTRY = 'idn' TRAIN_PATH, TEST_PATH, QUESTIONS_PATH = get_country_filepaths(COUNTRY) # Load and transform the training data X_train, y_train, w_train = load_data(TRAIN_PATH) # Load and transform the test data X_test, y_test, w_test = load_data(TEST_PATH) orig_index = X_train.index # Assert consistency before training assert X_train.shape[1] == X_test.shape[1] # Enforce consistency between features and labels y_train = pd.DataFrame(y_train, index=orig_index).loc[X_train.index] y_train = np.ravel(y_train.values) # NOTE: Make sure that the class is labeled 'target' in the data file # tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64) # features = tpot_data.drop('target', axis=1).values
import numpy as np from data.load_data import load_data from utils.args import args from utils.logger import logger from utils.calc_hamming_ranking import calc_hamming_ranking from dlfh_algo import dlfh_algo from hash_func import linear_hash if __name__ == "__main__": np.random.seed(args.seed) '''load dataset''' logger.info('load dataset: {}'.format(args.dataname)) test_text, test_image, test_label, database_text, database_image, database_label = load_data() '''learning procedure''' logger.info('start training procedure') start_t = time.time() db_image_codes, db_text_codes = dlfh_algo(train_labels=database_label) '''out-of-sample extension''' wx = linear_hash(database_image, db_image_codes) wy = linear_hash(database_text, db_text_codes) end_t = time.time() - start_t '''start encoding''' test_image_codes = np.sign(test_image.dot(wx)) test_text_codes = np.sign(test_text.dot(wy))
def trainer(train_dir_name, eval_dir_name, out_dir_name): ''' Train the model :param train_dir_name: path to training set directory :param eval_dir_name: path to evaluation set directory :param out_dir_name: output path to save model files :return: None ''' if not os.path.exists(out_dir_name): os.makedirs(out_dir_name) train_features, train_texts = load_data(train_dir_name) eval_features, eval_texts = load_data(eval_dir_name) steps_per_epoch = len(train_texts) / BATCH_SIZE print('Image file format is %s' % IMAGE_FILE_FORMAT) print('Keras backend file format is %s' % K.image_data_format()) print('Training images input shape: {}'.format(train_features.shape)) print('Evaluation images input shape: {}'.format(eval_features.shape)) print('Training texts shape: {}'.format(len(train_texts))) print('Evaluation texts input shape: {}'.format(len(eval_texts))) print('Epoch size: {}'.format(EPOCHS)) print('Batch size: {}'.format(BATCH_SIZE)) print('Steps per epoch: {}'.format(int(steps_per_epoch))) print('Kernel Initializer: {}'.format(KERNEL_INIT)) with open(os.path.join(out_dir_name, 'config.txt'), 'w') as fh: with redirect_stdout(fh): print('Image file format is %s' % IMAGE_FILE_FORMAT) print('Keras backend file format is %s' % K.image_data_format()) print('Training images input shape: {}'.format( train_features.shape)) print('Evaluation images input shape: {}'.format( eval_features.shape)) print('Training texts shape: {}'.format(len(train_texts))) print('Evaluation texts input shape: {}'.format(len(eval_texts))) print('Epoch size: {}'.format(EPOCHS)) print('Batch size: {}'.format(BATCH_SIZE)) print('Steps per epoch: {}'.format(int(steps_per_epoch))) print('Kernel Initializer: {}'.format(KERNEL_INIT)) # Prepare tokenizer to create the vocabulary tokenizer = Tokenizer(filters='', split=" ", lower=False) # Create the vocabulary tokenizer.fit_on_texts([load_doc('../data/code.vocab')]) # Initialize data generators for training and validation train_generator = DataGenerator(train_texts, train_features, batch_size=BATCH_SIZE, tokenizer=tokenizer, shuffle=True, image_data_format=IMAGE_FILE_FORMAT) validation_generator = DataGenerator(eval_texts, eval_features, batch_size=BATCH_SIZE, tokenizer=tokenizer, shuffle=True, image_data_format=IMAGE_FILE_FORMAT) # Initialize model model = CodeGeneratorModel(IMAGE_SIZE, out_dir_name, image_file_format=IMAGE_FILE_FORMAT, kernel_initializer=KERNEL_INIT) model.save_model() model.summarize() model.summarize_image_model() model.plot_model() if VALIDATE: model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch, callbacks=generate_callbacks(out_dir_name), validation_data=validation_generator) else: model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch, callbacks=generate_callbacks(out_dir_name))