def main(): args = parse_train_args() set_seed(manualSeed=args.seed) if args.optimizer == 'LBFGS': sys.exit('Support for training with 1st order methods!') device = torch.device( "cuda:" + str(args.gpu_id) if torch.cuda.is_available() else "cpu") args.device = device trainloader, _, num_classes = make_dataset(args.dataset, args.data_dir, args.batch_size, args.sample_size, SOTA=args.SOTA) if args.model == "MLP": model = models.__dict__[args.model](hidden=args.width, depth=args.depth, fc_bias=args.bias, num_classes=num_classes).to(device) elif args.model == "ResNet18_adapt": model = ResNet18_adapt(width=args.width, num_classes=num_classes, fc_bias=args.bias).to(device) else: model = models.__dict__[args.model](num_classes=num_classes, fc_bias=args.bias, ETF_fc=args.ETF_fc, fixdim=args.fixdim, SOTA=args.SOTA).to(device) train(args, model, trainloader)
def main(args): train_ds, valid_ds, datainfo = datasets.make_dataset(args.dataset_path) model = models.BaselineCNN1d(in_channels, 3) criterion = nn.MSELoss() if args.gpus > 0: model = model.cuda() criterion = criterion.cuda() optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) metrics = get_metrics(criterion, datainfo) callbacks = [EarlyStopping(metrics[0])] trainer = Trainer2(model, optim=optimizer, metrics=metrics, callbacks=callbacks, data_parallel=False, ncols=100, cpus=args.cpus, gpus=args.gpus) trainer.fit(train_ds, valid_ds, start_epoch=args.start_epoch, num_epochs=args.num_epochs, batch_size=args.batch_size, shuffle=False)
def main(args): train_ds, valid_ds, datainfo = datasets.make_dataset(args.dataset_path) model = models.RNNBaseline(input_size=6, hidden_size=12, num_layers=3) criterion = nn.MSELoss() if args.gpus > 0: model = model.cuda() criterion = criterion.cuda() optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) head_metric = utils.HeadProjectMetric('head') metrics = [ModuleMetric(criterion, 'loss'), head_metric] callbacks = [EarlyStopping(metrics)] trainer = Trainer2(model, optimizer, metrics, callbacks, ncols=100) trainer.fit(train_ds, valid_ds, start_epoch=args.start_epoch, num_epochs=args.num_epochs, batch_size=args.batch_size, shuffle=True) # metric 결과를 csv 파일로 저장 csv_filename = args.checkpoint_dir / 'metrics.csv' print('Write metric result into', csv_filename) head_metric.to_csv(csv_filename)
def init_dataset_iterator_local(self, features_config, batch_size=128, truncate_session_length=20): with tf.device('/cpu:0'): self.files_placeholder = tf.placeholder(tf.string) # Make a dataset ds = make_dataset(self.files_placeholder, features_config, batch_size=batch_size, truncate_sequence_length=truncate_session_length) # Define an abstract iterator that has the shape and type of our datasets iterator = tf.data.Iterator.from_structure(ds.output_types, ds.output_shapes) # This is an op that gets the next element from the iterator self.next_element_op = iterator.get_next() # These ops let us switch and reinitialize every time we finish an epoch self.iterator_init_op = iterator.make_initializer(ds)
def main(args): train_ds, valid_ds, datainfo = datasets.make_dataset(args.dataset_path) model = models.SimpleError() criterion = nn.MSELoss() if args.gpus > 0: model = model.cuda() criterion = criterion.cuda() optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) metrics = [ ModuleMetric(criterion, 'loss'), utils.HeadProjectMetric('head') ] callbacks = [EarlyStopping(metrics)] trainer = Trainer2(model, optimizer, metrics, callbacks, ncols=100) trainer.fit(train_ds, valid_ds, start_epoch=args.start_epoch, num_epochs=args.num_epochs, batch_size=args.batch_size, shuffle=True)
def main(): args = parse_train_args() if args.optimizer != 'LBFGS': sys.exit('Support for training with LBFGS only!') device = torch.device( "cuda:" + str(args.gpu_id) if torch.cuda.is_available() else "cpu") args.device = device trainloader, _, num_classes = make_dataset(args.dataset, args.data_dir, args.batch_size, args.sample_size, SOTA=args.SOTA) model = models.__dict__[args.model](num_classes=num_classes, fc_bias=args.bias, ETF_fc=args.ETF_fc, fixdim=args.fixdim, SOTA=args.SOTA).to(device) print('# of model parameters: ' + str(count_network_parameters(model))) train(args, model, trainloader)
def main(): args = parse_args() config_path = args.config_file_path config = get_config(config_path, new_keys_allowed=True) config.defrost() config.experiment_dir = os.path.join(config.log_dir, config.experiment_name) config.tb_dir = os.path.join(config.experiment_dir, 'tb') config.model.best_checkpoint_path = os.path.join(config.experiment_dir, 'best_checkpoint.pt') config.model.last_checkpoint_path = os.path.join(config.experiment_dir, 'last_checkpoint.pt') config.config_save_path = os.path.join(config.experiment_dir, 'segmentation_config.yaml') config.freeze() init_experiment(config) set_random_seed(config.seed) train_dataset = make_dataset(config.train.dataset) train_loader = make_data_loader(config.train.loader, train_dataset) val_dataset = make_dataset(config.val.dataset) val_loader = make_data_loader(config.val.loader, val_dataset) device = torch.device(config.device) model = make_model(config.model).to(device) optimizer = make_optimizer(config.optim, model.parameters()) scheduler = None loss_f = make_loss(config.loss) early_stopping = EarlyStopping( **config.stopper.params ) train_writer = SummaryWriter(log_dir=os.path.join(config.tb_dir, 'train')) val_writer = SummaryWriter(log_dir=os.path.join(config.tb_dir, 'val')) for epoch in range(1, config.epochs + 1): print(f'Epoch {epoch}') train_metrics = train(model, optimizer, train_loader, loss_f, device) write_metrics(epoch, train_metrics, train_writer) print_metrics('Train', train_metrics) val_metrics = val(model, val_loader, loss_f, device) write_metrics(epoch, val_metrics, val_writer) print_metrics('Val', val_metrics) early_stopping(val_metrics['loss']) if config.model.save and early_stopping.counter == 0: torch.save(model.state_dict(), config.model.best_checkpoint_path) print('Saved best model checkpoint to disk.') if early_stopping.early_stop: print(f'Early stopping after {epoch} epochs.') break if scheduler: scheduler.step() train_writer.close() val_writer.close() if config.model.save: torch.save(model.state_dict(), config.model.last_checkpoint_path) print('Saved last model checkpoint to disk.')
def regen_dataset(model, in_data_dir, in_gt_dir, out_data_dir, out_gt_dir, sample_per_file, size_input, transform_joint, transform_img, transform_target, transform_reverse, test_batch_size, max_test_per_file, prec_th, rec_th): import scipy.misc gpu_time = AverageMeter() data_time = AverageMeter() write_time = AverageMeter() file_list = datasets.make_dataset(in_data_dir, in_gt_dir, do_copy=False) rm_old_mk_new_dir(out_data_dir) rm_old_mk_new_dir(out_gt_dir) model.eval() # switch to evaluate mode model.cuda() time_start = time.time() count = 0 # count processed files for count_files, file_path in enumerate(file_list): sample_saved, sample_tested = 0, 0 img = datasets.default_loader(file_path[0], is_target=False) gt = datasets.default_loader(file_path[1], is_target=True) while sample_tested < max_test_per_file: input_, target = None, None input_, target = transform_joint(img, gt) input_, target = transform_img(input_), transform_target(target) input_, target = input_.unsqueeze(0), target.unsqueeze(0) for b in range(test_batch_size): tmp_input, tmp_target = transform_joint(img, gt) tmp_input, tmp_target = transform_img( tmp_input), transform_target(tmp_target) tmp_input = tmp_input.unsqueeze(0) input_ = torch.cat((input_, tmp_input), dim=0) target = torch.cat((target, tmp_target), dim=0) sample_tested += test_batch_size input_var = torch.autograd.Variable(input_, volatile=True) target = target.long() data_time.update(time.time() - time_start) # data loading time time_start = time.time() # time reset # compute output output = model(input_var) gpu_time.update(time.time() - time_start) # computation time time_start = time.time() # time reset prec_batch, recall_batch = get_prec_recall_batch( output.data.cpu(), target) ind_to_save = (prec.lt(prec_th) * recall.lt(rec_th)).eq(1) # binary for i in range(ind_to_save.size(0)): if ind_to_save[i] == 0: continue out_img = transform_reverse(input_[i, :, :, :]).numpy() out_img = np.around(out_img * 255).astype(np.uint8) out_img = np.transpose(out_img, (1, 2, 0)) out_gt = (target[i, :, :].numpy() * 255).astype(np.uint8) count += 1 fname = str(count) + ".png" scipy.misc.imsave(os.path.join(out_data_dir, fname), out_img) scipy.misc.imsave(os.path.join(out_gt_dir, fname), out_gt) write_time.update(time.time() - time_start) # data loading time time_start = time.time() # time reset print('File (Tested): [{0}({1})]\t' 'Time {gpu_time.val:.3f} ({gpu_time.avg:.3f})\t' 'Data {data_time.val:.3f} ({data_time.avg:.3f})\t' 'Write {write_time.val:.3f} ({write_time.avg:.3f})'.format( count_files + 1, sample_tested, gpu_time=gpu_time, data_time=data_time, write_time=write_time))
from utils.filereader import read_inputs from datasets import make_dataset from roaddecider import Decider samples1 = read_inputs( '/home/wifi/PycharmProjects/data-extractor/data_extractor/service/examples', 'output.csv') samples2 = read_inputs( '/home/wifi/PycharmProjects/data-extractor/data_extractor/service/examples', 'output2.csv') decider1 = Decider(inputs=samples1, name='rsu1') decider2 = Decider(inputs=samples2, name='rsu2') trainsamples, traintargets = make_dataset() decider1.clf.fit(trainsamples, traintargets) decider2.clf.fit(trainsamples, traintargets) rtargets1 = decider1.verify_road() rtargets2 = decider2.verify_road() decider_manager = DeciderManager() best = decider_manager.compare([decider1, decider2]) print('melhor caminho [geral] : %s' % best.name) best_per_hour = decider_manager.compare([decider1, decider2], hour=16) print('melhor caminho [horario, %d] : %s' % (16, best_per_hour.name)) print(decider1.eval(16)) print(decider2.eval(16))
exportsvg(svgDir, exportDir, exportFormat)''' def Erosion(img, kernalSize=2, mode=1): #img = GetImg(imgPath, mode) kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernalSize, kernalSize)) #ret,erosion = cv2.threshold(img,,255,cv2.THRESH_BINARY) erosion = cv2.erode(img, kernel, iterations=1) #_, erosion = cv2.threshold(erosion,127,255,cv2.THRESH_BINARY) return erosion if __name__ == '__main__': #originlist = make_dataset('../../../data/manga/modifysvg') svglist = make_dataset('../../../data/manga/png') #print(len(svglist), len(originlist)) '''print('stroke') for i in range(len(originlist)): change_width(originlist[i])''' print('export') #os.mkdir('../../../data/manga/png1') #exportsvg('../../../data/manga/modifysvg', '../../../data/manga/png1') #os.mkdir('../../../data/manga/train/lineA/') #svglist = make_dataset('../../../data/manga/png1') print('resize') for i in range(len(svglist)): if i % 100 == 0: print(svglist[i]) if i % 17 == 0: outf = '../../../data/manga/test/lineA/'
def main(): torch.backends.cudnn.deterministic = True cudnn.benchmark = True #parser = argparse.ArgumentParser(description="ReID Baseline Training") #parser.add_argument( #"--config_file", default="", help="path to config file", type=str) #parser.add_argument("opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER) #args = parser.parse_args() config_file = 'configs/baseline_veri_r101_a.yml' if config_file != "": cfg.merge_from_file(config_file) #cfg.merge_from_list(args.opts) cfg.freeze() output_dir = cfg.OUTPUT_DIR if output_dir and not os.path.exists(output_dir): os.makedirs(output_dir) logger = setup_logger("reid_baseline", output_dir, if_train=True) logger.info("Saving model in the path :{}".format(cfg.OUTPUT_DIR)) logger.info(config_file) if config_file != "": logger.info("Loaded configuration file {}".format(config_file)) with open(config_file, 'r') as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID path = 'D:/Python_SMU/Veri/verigms/gms/' pkl = {} entries = os.listdir(path) for name in entries: f = open((path + name), 'rb') if name == 'featureMatrix.pkl': s = name[0:13] else: s = name[0:3] pkl[s] = pickle.load(f) f.close with open('cids.pkl', 'rb') as handle: b = pickle.load(handle) with open('index.pkl', 'rb') as handle: c = pickle.load(handle) train_transforms, val_transforms, dataset, train_set, val_set = make_dataset( cfg, pkl_file='index.pkl') num_workers = cfg.DATALOADER.NUM_WORKERS num_classes = dataset.num_train_pids #pkl_f = 'index.pkl' pid = 0 pidx = {} for img_path, pid, _, _ in dataset.train: path = img_path.split('\\')[-1] folder = path[1:4] pidx[folder] = pid pid += 1 if 'triplet' in cfg.DATALOADER.SAMPLER: train_loader = DataLoader(train_set, batch_size=cfg.SOLVER.IMS_PER_BATCH, sampler=RandomIdentitySampler( dataset.train, cfg.SOLVER.IMS_PER_BATCH, cfg.DATALOADER.NUM_INSTANCE), num_workers=num_workers, pin_memory=True, collate_fn=train_collate_fn) elif cfg.DATALOADER.SAMPLER == 'softmax': print('using softmax sampler') train_loader = DataLoader(train_set, batch_size=cfg.SOLVER.IMS_PER_BATCH, shuffle=True, num_workers=num_workers, pin_memory=True, collate_fn=train_collate_fn) else: print('unsupported sampler! expected softmax or triplet but got {}'. format(cfg.SAMPLER)) print("train loader loaded successfully") val_loader = DataLoader(val_set, batch_size=cfg.TEST.IMS_PER_BATCH, shuffle=False, num_workers=num_workers, pin_memory=True, collate_fn=train_collate_fn) print("val loader loaded successfully") if cfg.MODEL.PRETRAIN_CHOICE == 'finetune': model = make_model(cfg, num_class=576) model.load_param_finetune(cfg.MODEL.PRETRAIN_PATH) print('Loading pretrained model for finetuning......') else: model = make_model(cfg, num_class=num_classes) loss_func, center_criterion = make_loss(cfg, num_classes=num_classes) optimizer, optimizer_center = make_optimizer(cfg, model, center_criterion) scheduler = WarmupMultiStepLR(optimizer, cfg.SOLVER.STEPS, cfg.SOLVER.GAMMA, cfg.SOLVER.WARMUP_FACTOR, cfg.SOLVER.WARMUP_EPOCHS, cfg.SOLVER.WARMUP_METHOD) print("model,optimizer, loss, scheduler loaded successfully") height, width = cfg.INPUT.SIZE_TRAIN log_period = cfg.SOLVER.LOG_PERIOD checkpoint_period = cfg.SOLVER.CHECKPOINT_PERIOD eval_period = cfg.SOLVER.EVAL_PERIOD device = "cuda" epochs = cfg.SOLVER.MAX_EPOCHS logger = logging.getLogger("reid_baseline.train") logger.info('start training') if device: if torch.cuda.device_count() > 1: print('Using {} GPUs for training'.format( torch.cuda.device_count())) model = nn.DataParallel(model) model.to(device) loss_meter = AverageMeter() acc_meter = AverageMeter() evaluator = R1_mAP_eval(len(dataset.query), max_rank=50, feat_norm=cfg.TEST.FEAT_NORM) model.base._freeze_stages() logger.info('Freezing the stages number:{}'.format(cfg.MODEL.FROZEN)) data_index = search(pkl) print("Ready for training") for epoch in range(1, epochs + 1): start_time = time.time() loss_meter.reset() acc_meter.reset() evaluator.reset() scheduler.step() model.train() for n_iter, (img, label, index, pid, cid) in enumerate(train_loader): optimizer.zero_grad() optimizer_center.zero_grad() #img = img.to(device) #target = vid.to(device) trainX, trainY = torch.zeros( (train_loader.batch_size * 3, 3, height, width), dtype=torch.float32), torch.zeros( (train_loader.batch_size * 3), dtype=torch.int64) for i in range(train_loader.batch_size): labelx = label[i] indexx = index[i] cidx = pid[i] if indexx > len(pkl[labelx]) - 1: indexx = len(pkl[labelx]) - 1 a = pkl[labelx][indexx] minpos = np.argmin(ma.masked_where(a == 0, a)) pos_dic = train_set[data_index[cidx][1] + minpos] #print(pos_dic[1]) neg_label = int(labelx) while True: neg_label = random.choice(range(1, 770)) if neg_label is not int(labelx) and os.path.isdir( os.path.join('D:/datasets/veri-split/train', strint(neg_label))) is True: break negative_label = strint(neg_label) neg_cid = pidx[negative_label] neg_index = random.choice(range(0, len(pkl[negative_label]))) neg_dic = train_set[data_index[neg_cid][1] + neg_index] trainX[i] = img[i] trainX[i + train_loader.batch_size] = pos_dic[0] trainX[i + (train_loader.batch_size * 2)] = neg_dic[0] trainY[i] = cidx trainY[i + train_loader.batch_size] = pos_dic[3] trainY[i + (train_loader.batch_size * 2)] = neg_dic[3] #print(trainY) trainX = trainX.cuda() trainY = trainY.cuda() score, feat = model(trainX, trainY) loss = loss_func(score, feat, trainY) loss.backward() optimizer.step() if 'center' in cfg.MODEL.METRIC_LOSS_TYPE: for param in center_criterion.parameters(): param.grad.data *= (1. / cfg.SOLVER.CENTER_LOSS_WEIGHT) optimizer_center.step() acc = (score.max(1)[1] == trainY).float().mean() loss_meter.update(loss.item(), img.shape[0]) acc_meter.update(acc, 1) if (n_iter + 1) % log_period == 0: logger.info( "Epoch[{}] Iteration[{}/{}] Loss: {:.3f}, Acc: {:.3f}, Base Lr: {:.2e}" .format(epoch, (n_iter + 1), len(train_loader), loss_meter.avg, acc_meter.avg, scheduler.get_lr()[0])) end_time = time.time() time_per_batch = (end_time - start_time) / (n_iter + 1) logger.info( "Epoch {} done. Time per batch: {:.3f}[s] Speed: {:.1f}[samples/s]" .format(epoch, time_per_batch, train_loader.batch_size / time_per_batch)) if epoch % checkpoint_period == 0: torch.save( model.state_dict(), os.path.join(cfg.OUTPUT_DIR, cfg.MODEL.NAME + '_{}.pth'.format(epoch))) if epoch % eval_period == 0: model.eval() for n_iter, (img, vid, camid, _, _) in enumerate(val_loader): with torch.no_grad(): img = img.to(device) feat = model(img) evaluator.update((feat, vid, camid)) cmc, mAP, _, _, _, _, _ = evaluator.compute() logger.info("Validation Results - Epoch: {}".format(epoch)) logger.info("mAP: {:.1%}".format(mAP)) for r in [1, 5, 10]: logger.info("CMC curve, Rank-{:<3}:{:.1%}".format( r, cmc[r - 1]))
def main(): args = parse_eval_args() if args.load_path is None: sys.exit('Need to input the path to a pre-trained model!') device = torch.device( "cuda:" + str(args.gpu_id) if torch.cuda.is_available() else "cpu") args.device = device trainloader, testloader, num_classes = make_dataset( args.dataset, args.data_dir, args.batch_size, args.sample_size) if args.model == "MLP": model = models.__dict__[args.model](hidden=args.width, depth=args.depth, fc_bias=args.bias, num_classes=num_classes).to(device) elif args.model == "ResNet18_adapt": model = ResNet18_adapt(width=args.width, num_classes=num_classes, fc_bias=args.bias).to(device) else: model = models.__dict__[args.model](num_classes=num_classes, fc_bias=args.bias, ETF_fc=args.ETF_fc, fixdim=args.fixdim, SOTA=args.SOTA).to(device) fc_features = FCFeatures() model.fc.register_forward_pre_hook(fc_features) info_dict = { 'collapse_metric': [], 'ETF_metric': [], 'WH_relation_metric': [], 'Wh_b_relation_metric': [], 'W': [], 'b': [], 'H': [], 'mu_G_train': [], # 'mu_G_test': [], 'train_acc1': [], 'train_acc5': [], 'test_acc1': [], 'test_acc5': [] } logfile = open('%s/test_log.txt' % (args.load_path), 'w') for i in range(args.epochs): model.load_state_dict( torch.load(args.load_path + 'epoch_' + str(i + 1).zfill(3) + '.pth')) model.eval() for n, p in model.named_parameters(): if 'fc.weight' in n: W = p if 'fc.bias' in n: b = p mu_G_train, mu_c_dict_train, train_acc1, train_acc5 = compute_info( args, model, fc_features, trainloader, isTrain=True) mu_G_test, mu_c_dict_test, test_acc1, test_acc5 = compute_info( args, model, fc_features, testloader, isTrain=False) Sigma_W = compute_Sigma_W(args, model, fc_features, mu_c_dict_train, trainloader, isTrain=True) # Sigma_W_test_norm = compute_Sigma_W(args, model, fc_features, mu_c_dict_train, testloader, isTrain=False) Sigma_B = compute_Sigma_B(mu_c_dict_train, mu_G_train) collapse_metric = np.trace( Sigma_W @ scilin.pinv(Sigma_B)) / len(mu_c_dict_train) ETF_metric = compute_ETF(W) WH_relation_metric, H = compute_W_H_relation(W, mu_c_dict_train, mu_G_train) if args.bias: Wh_b_relation_metric = compute_Wh_b_relation(W, mu_G_train, b) else: Wh_b_relation_metric = compute_Wh_b_relation( W, mu_G_train, torch.zeros((W.shape[0], ))) info_dict['collapse_metric'].append(collapse_metric) info_dict['ETF_metric'].append(ETF_metric) info_dict['WH_relation_metric'].append(WH_relation_metric) info_dict['Wh_b_relation_metric'].append(Wh_b_relation_metric) info_dict['W'].append((W.detach().cpu().numpy())) if args.bias: info_dict['b'].append(b.detach().cpu().numpy()) info_dict['H'].append(H.detach().cpu().numpy()) info_dict['mu_G_train'].append(mu_G_train.detach().cpu().numpy()) # info_dict['mu_G_test'].append(mu_G_test.detach().cpu().numpy()) info_dict['train_acc1'].append(train_acc1) info_dict['train_acc5'].append(train_acc5) info_dict['test_acc1'].append(test_acc1) info_dict['test_acc5'].append(test_acc5) print_and_save( '[epoch: %d] | train top1: %.4f | train top5: %.4f | test top1: %.4f | test top5: %.4f ' % (i + 1, train_acc1, train_acc5, test_acc1, test_acc5), logfile) with open(args.load_path + 'info.pkl', 'wb') as f: pickle.dump(info_dict, f)
def test_cnn(data_nm, train_size, cv=5, use_classes='all', composition=None, class_weight=None, model='simple_cnn', batch_size=32, epochs=100): balanced = False if composition is not None else True dataset = make_dataset(data_nm, train_size, use_classes=use_classes, balanced=balanced, composition=composition) y = dataset['train_labels'] y_test = dataset['test_labels'] dataset = preprocess_dataset(dataset) n_classes = len(np.unique(y)) skf = StratifiedKFold(cv, shuffle=True, random_state=42) y_preds, models, histories = [], [], [] for i, (train_idx, val_idx) in enumerate(skf.split(dataset['train_images'], y), 1): X_train = dataset['train_images'][train_idx] y_train = dataset['train_labels'][train_idx] X_val = dataset['train_images'][val_idx] y_val = dataset['train_labels'][val_idx] if model == 'resnet50': model = build_resnet50(X_train[0].shape, n_classes) else: model = build_simple_cnn(X_train[0].shape, n_classes) model.compile(SGD(1e-3, momentum=0.9), loss='categorical_crossentropy', metrics=['acc']) hist = model.fit(X_train, y_train, validation_data=[X_val, y_val], batch_size=batch_size, epochs=epochs, verbose=0, class_weight=class_weight) val_loss, val_acc = model.evaluate(X_val, y_val, verbose=0) print(f'fold{i} loss:{val_loss} acc:{val_acc}') y_pred = np.argmax(model.predict(X_val), 1) y_pred = pd.Series(y_pred, index=val_idx) y_preds.append(y_pred) models.append(model) histories.append(hist.history) y_preds = pd.concat(y_preds).sort_index().values y_test_preds = np.array( [model.predict(dataset['test_images']) for model in models]) y_test_preds = y_test_preds.sum(0).argmax(1) train_acc = accuracy_score(y, y_preds) test_acc = accuracy_score(y_test, y_test_preds) print(f'train acc:{train_acc} test acc:{test_acc}') history_ = { k: np.mean([hist[k] for hist in histories], 0) for k in histories[0].keys() } plot_history(history_) return train_acc, test_acc