def try_wrapped(tree, args, func_name="test_me"): copy_tree = copy.deepcopy(tree) exec_tree = visitor.wrap_function(tree, args, func_name) trace = [] code = compile(exec_tree, filename='<blah>', mode='exec') namespace = {} exec(code, namespace) blockPrint() import time start = time.time() namespace['wrapper'](trace) end = time.time() enablePrint() if end - start > 10: from utils import TimeExceeded raise TimeExceeded return trace
def exp(args, fold_idx, train_set, valid_set, test_set): path = args.save_root + args.result_dir if not os.path.isdir(path): os.makedirs(path) os.makedirs(path + '/models') os.makedirs(path + '/logs') logger = eegdg_logger(path + f'/logs/{fold_idx}') with open(path + '/args.txt', 'w') as f: f.write(str(args)) import torch.cuda cuda = torch.cuda.is_available() # check if GPU is available, if True chooses to use it device = 'cuda' if cuda else 'cpu' if cuda: torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False seed = args.seed random.seed(seed) torch.manual_seed(seed) if cuda: torch.cuda.manual_seed_all(seed) np.random.seed(seed) train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True) valid_loader = torch.utils.data.DataLoader(valid_set, batch_size=args.batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(test_set, batch_size=args.batch_size, shuffle=False) model = models.get_model(args) # model = FcClfNet(embedding_net) # model = torch.nn.DataParallel(model) mb_params = utils.param_size(model) print(f"Model size = {mb_params:.4f} MB") if cuda: model.cuda(device=device) print(model) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, weight_decay=1e-4, momentum=0.9) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs - 1) results_columns = [ f'valid_loss', f'test_loss', f'valid_accuracy', f'test_accuracy' ] df = pd.DataFrame(columns=results_columns) valid_acc = 0 valid_min_loss = 100 best_acc = 0 best_acc_loss = 0 max_acc = 0 n_epochs_stop = 200 epochs_no_improve = 0 early_stop = False for epochidx in range(1, args.epochs): print(epochidx) start = time.time() train(10, model, device, train_loader, optimizer, scheduler, cuda, args.gpuidx) print(f'total time: {time.time()-start}') utils.blockPrint() train_loss, train_score = eval(model, device, train_loader) valid_loss, valid_score = eval(model, device, valid_loader) test_loss, test_score = eval(model, device, test_loader) utils.enablePrint() scheduler.step() lr = scheduler.get_last_lr()[0] print(f'LR : {lr}') logger.log_training(train_loss, train_score, test_loss, test_score, lr, epochidx) results = { f'valid_loss': valid_loss, f'test_loss': test_loss, f'valid_accuracy': valid_score, f'test_accuracy': test_score } df = df.append(results, ignore_index=True) print(results) if valid_score > valid_acc: valid_acc = valid_score best_acc = test_score torch.save( model.state_dict(), os.path.join(path, 'models', f"model_fold{fold_idx}_best.pt")) best_epoch = epochidx if valid_loss < valid_min_loss: #모델이 개선된경우 valid_min_loss = valid_loss best_acc_loss = test_score torch.save( model.state_dict(), os.path.join(path, 'models', f"model_fold{fold_idx}_best(loss).pt")) best_loss_epoch = epochidx epochs_no_improve = 0 else: epochs_no_improve += 1 if test_score > max_acc: max_acc = test_score torch.save( model.state_dict(), os.path.join(path, 'models', f"model_fold{fold_idx}_max.pt")) max_epoch = epochidx print(f'current best acc : {best_acc:.4f} at epoch {best_epoch}') print( f'current best(loss) acc : {best_acc_loss:.4f} at epoch {best_loss_epoch}' ) print(f'current max acc : {max_acc:.4f} at epoch {max_epoch}') if epochidx > 5 and epochs_no_improve == n_epochs_stop: print('Early stopping!') early_stop = True break else: continue if early_stop: print("Stopped") best_model = models.get_model(args) best_model.load_state_dict( torch.load(os.path.join(path, 'models', f"model_fold{fold_idx}_best.pt"), map_location=device)) if cuda: best_model.cuda(device=device) print("best accuracy") _, _ = eval(best_model, device, test_loader) df = utils.get_testset_accuracy(best_model, device, test_set, args) return df
if srDivider > 1: samplingRate /= srDivider audioData = audioData[::srDivider] gc.collect() audioData = np.swapaxes(audioData, 0, 1) spectos = [] imfFeatures = [] for eachChannel in audioData: utils.blockPrint( ) # block unwanted prints from emd implementation # detail params: threshold_1=0.000001, threshold_2=0.00001 decomposer = pyhht.emd.EMD(eachChannel, n_imfs=numberOfImfs) decomposedSignals = decomposer.decompose() utils.enablePrint() imfs = decomposedSignals[:-1] # last element is residue # print(np.shape(imfs)) # Calculate Magnitudes from IMFs(before normalization) mags = [] instfs = [] phases = [] for imf in imfs: hx = sp.hilbert(imf) # magnitude mag = np.abs( hx) # magnitudes obtained before normalization mags.append(mag) # phase phx = np.unwrap(np.arctan2(hx.imag, hx.real))
if i % 10 == 0 or bsz < batch_size: loss_count /= 10 if bsz == batch_size else i % 10 print('Epoch [%d/%d], Step [%d/%d], Loss: %.4f, Perplexity: %5.4f' % (epoch, num_epochs, i, total_step, loss_count, np.exp(loss_count))) loss_count = 0 tokens = banet.decoder.sample(video_encoded) tokens = tokens.data[0].squeeze() we = banet.decoder.decode_tokens(tokens) gt = banet.decoder.decode_tokens(captions[0].squeeze()) print('[vid:%d]' % video_ids[0]) print('WE: %s\nGT: %s' % (we, gt)) torch.save(banet.state_dict(), banet_pth_path) torch.save(optimizer.state_dict(), optimizer_pth_path) # 计算一下在val集上的性能并记录下来 blockPrint() banet.eval() metrics = evaluate(vocab, banet, test_range, test_prediction_txt_path, reference) enablePrint() for k, v in metrics.items(): log_value(k, v, epoch) print('%s: %.6f' % (k, v)) if k == 'METEOR' and v > best_meteor: # 备份在val集上METEOR值最好的模型 shutil.copy2(banet_pth_path, best_banet_pth_path) shutil.copy2(optimizer_pth_path, best_optimizer_pth_path) best_meteor = v banet.train()
def exp(args, fold_idx, train_set, valid_set, test_set): path = args.save_root + args.result_dir if not os.path.isdir(path): os.makedirs(path) os.makedirs(path + '/models') with open(path + '/args.txt', 'w') as f: f.write(str(args)) import torch.cuda cuda = torch.cuda.is_available() device = 'cuda' if cuda else 'cpu' if cuda: torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False seed = args.seed random.seed(seed) torch.manual_seed(seed) if cuda: torch.cuda.manual_seed_all(seed) np.random.seed(seed) train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True, pin_memory=False) valid_loader = torch.utils.data.DataLoader(valid_set, batch_size=args.batch_size, shuffle=False) test_loader = torch.utils.data.DataLoader(test_set, batch_size=args.batch_size, shuffle=False) temp = torch.utils.data.Subset(train_set, range(100, 200)) model = Net(args.n_class, args.n_ch, args.n_time) mb_params = utils.param_size(model) print(f"Model size = {mb_params:.4f} MB") if cuda: model.cuda(device=device) print(model) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs) results_columns = [f'valid_loss', f'test_loss', f'valid_accuracy', f'test_accuracy'] df = pd.DataFrame(columns=results_columns) valid_min_loss = float('inf') best_acc_loss = 0 for epochidx in range(1, args.epochs): print(epochidx) train(10, model, device, train_loader, optimizer, scheduler, cuda, args.gpuidx) valid_loss, valid_score, _ = eval(model, device, valid_loader) test_loss, test_score, _ = eval(model, device, test_loader) results = {f'valid_loss': valid_loss, f'test_loss': test_loss, f'valid_accuracy': valid_score, f'test_accuracy': test_score} df = df.append(results, ignore_index=True) print(results) scheduler.step() lr = scheduler.get_last_lr()[0] print(f'LR : {lr}') if valid_loss < valid_min_loss: valid_min_loss = valid_loss best_acc_loss = test_score torch.save(model.state_dict(), os.path.join( path, 'models', f"model_fold{fold_idx}.pt")) best_loss_epoch = epochidx print(f'current best(loss) acc : {best_acc_loss:.4f} at epoch {best_loss_epoch}') best_model = Net(args.n_class, args.n_ch, args.n_time) best_model.load_state_dict(torch.load(os.path.join( path, 'models', f"model_fold{fold_idx}.pt"), map_location=device)) if cuda: best_model.cuda(device=device) print("best accuracy") _, test_score, _ = eval(best_model, device, test_loader) utils.enablePrint() print(f"subject:{fold_idx}, acc:{test_score}") df = pd.DataFrame(np.array(test_score).reshape(-1, 1), columns=['sess2-on']) print(f"all acc: {np.mean(test_score):.4f}") return df