def main(): # Training settings parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--batch-size', type=int, default=128, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=60, metavar='N', help='number of epochs to train (default: 14)') parser.add_argument('--lr', type=float, default=1e-4, metavar='LR', help='learning rate (default: 1.0)') parser.add_argument('--gamma', type=float, default=0.7, metavar='M', help='Learning rate step gamma (default: 0.7)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--attention', type=str2bool, default=True, help='use attention module or not') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument( '--intensity', type=str2bool, default=False, metavar='I', help='whether multilabel problem is treated as intensity or label') parser.add_argument( '--eval_mode', type=str2bool, default=False, metavar='E', help='whether evaluate the model only without training') parser.add_argument( '--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--feature-train-path', type=str, help='the file of the fbank of training data',\ default=os.path.join(prefix,folder,"train_{}.h5".format(feature_name))) #default=os.path.join(prefix,folder,"train_{}.h5".format(feature_name))) parser.add_argument('--emo-train-path', type=str, help='the file of the target of training data',\ #default=os.path.join(prefix,"full_mode/merged/merged_idp_lena_google_freesound/","train_selected_cnn_combined{}_multiple_label.h5".format(fold))) default=os.path.join(prefix,folder,"train_label{}.h5".format(fold))) parser.add_argument('--feature-test-path', type=str, help='the file of the fbank of testing data',\ default=os.path.join(prefix,folder,"test_{}.h5".format(feature_name))) #default=os.path.join(prefix,folder,"test_{}.h5".format(feature_name))) parser.add_argument('--emo-test-path', type=str, help='the file of the target of testing data',\ default=os.path.join(prefix,folder,"test_label{}.h5".format(fold))) parser.add_argument('--load', type=str, default=None, help="Specify if want to load emotion model") parser.add_argument('--save', type=str, help='For Saving the emotion Model', default=None) #default="model/idp_lena_5way_combined{}_multiple_fisher_1000_weighted_sampler.pt".format(fold)) parser.add_argument('--joint', type=str2bool, default="False", help='if training the joint tier') parser.add_argument('--weighted_sampler', action='store_true', default=False, help='use weighted sampler or not, default not use') args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} num_classes = util.get_num_classes(args.emo_test_path) data_type = args.emo_test_path.split('/')[5] shuffle = True if data_type == "streaming" or args.eval_mode: shuffle = False feature_dim = util.get_feature_dim(args.feature_test_path) labels, _ = util.read_h5(args.emo_train_path) weights = torch.DoubleTensor( util.make_weights_balance_classes(labels.flatten())) sampler = torch.utils.data.sampler.WeightedRandomSampler(weights, len(weights), replacement=True) train_loader = torch.utils.data.DataLoader(dataset=util.dataset_lena_h5( args.feature_train_path, args.emo_train_path), collate_fn=util.collate_lena_fn, batch_size=args.batch_size, shuffle=True, **kwargs) if args.weighted_sampler: print("Use weighted sampler") train_loader = torch.utils.data.DataLoader( dataset=util.dataset_lena_h5(args.feature_train_path, args.emo_train_path), collate_fn=util.collate_lena_fn, batch_size=args.batch_size, sampler=sampler, **kwargs) test_loader = torch.utils.data.DataLoader(dataset=util.dataset_lena_h5( args.feature_test_path, args.emo_test_path), collate_fn=util.collate_lena_fn, batch_size=args.batch_size, shuffle=shuffle, **kwargs) model = Net(num_filters=384, num_classes=num_classes, attention=args.attention).to(device) model = load_pretrain_model(model, args.load, device) #train emotion classifier optimizer = optim.RMSprop(model.parameters(), lr=args.lr) #scheduler = StepLR(optimizer, step_size=20, gamma=0.1) if args.eval_mode: if args.joint: test_joint_tier(args, model, device, test_loader) else: test(args, model, device, test_loader) else: best_acc = -1 uar = -1 f1_mac = -1 for epoch in range(args.epochs): train(args, model, device, train_loader, optimizer, epoch, args.joint) if args.joint: curr_f1, curr_f1_mac, curr_acc, curr_cm, curr_built_in_error = test_joint_tier( args, model, device, test_loader) avg_f1 = sum(curr_f1) / len(curr_f1) avg_f1_mac = sum(curr_f1_mac) / len(curr_f1_mac) avg_acc = sum(curr_acc) / len(curr_acc) if avg_acc > best_acc: f1 = curr_f1 f1_mac = curr_f1_mac best_acc = curr_acc cm = curr_cm best_epoch = epoch best_built_in_error = curr_built_in_error save_model(model, args.save) else: curr_f1, curr_f1_mac, curr_acc, curr_uar, curr_cm = test( args, model, device, test_loader) if curr_f1_mac > f1_mac: f1 = curr_f1 f1_mac = curr_f1_mac best_acc = curr_acc uar = curr_uar cm = curr_cm best_epoch = epoch save_model(model, args.save) print("epoch", best_epoch) if args.joint: print("Best accuracy are ", acc) print("Best F1 weighted scores are ", f1) print("Best F1 macro scores are ", f1_mac) print("Average of Best Acc, weighted F1, macro F1", sum(acc) / len(acc), sum(f1) / len(f1), sum(f1_mac) / len(f1_mac)) print("Confusion matrices", cm) else: print("Best accuracy is ", best_acc) print("Best F1 weighted score is ", f1) print("Best F1 macro score is ", f1_mac) print("Best uar is", uar) print("Confusion matrix", cm) return best_acc, f1_mac, f1, cm
def main(): args.num_classes = get_num_classes(args.dataset) model = SGN(args.num_classes, args.dataset, args.seg, args) total = get_n_params(model) print(model) print('The number of parameters: ', total) print('The modes is:', args.network) if torch.cuda.is_available(): print('It is using GPU!') model = model.cuda() criterion = LabelSmoothingLoss(args.num_classes, smoothing=0.1).cuda() optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) if args.monitor == 'val_acc': mode = 'max' monitor_op = np.greater best = -np.Inf str_op = 'improve' elif args.monitor == 'val_loss': mode = 'min' monitor_op = np.less best = np.Inf str_op = 'reduce' scheduler = MultiStepLR(optimizer, milestones=[60, 90, 110], gamma=0.1) # Data loading ntu_loaders = NTUDataLoaders(args.dataset, args.case, seg=args.seg) train_loader = ntu_loaders.get_train_loader(args.batch_size, args.workers) val_loader = ntu_loaders.get_val_loader(args.batch_size, args.workers) train_size = ntu_loaders.get_train_size() val_size = ntu_loaders.get_val_size() test_loader = ntu_loaders.get_test_loader(32, args.workers) print('Train on %d samples, validate on %d samples' % (train_size, val_size)) best_epoch = 0 output_dir = make_dir(args.dataset) save_path = os.path.join(output_dir, args.network) if not os.path.exists(save_path): os.makedirs(save_path) checkpoint = osp.join(save_path, '%s_best.pth' % args.case) earlystop_cnt = 0 csv_file = osp.join(save_path, '%s_log.csv' % args.case) log_res = list() lable_path = osp.join(save_path, '%s_lable.txt' % args.case) pred_path = osp.join(save_path, '%s_pred.txt' % args.case) # Training if args.train == 1: for epoch in range(args.start_epoch, args.max_epochs): print(epoch, optimizer.param_groups[0]['lr']) t_start = time.time() train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch) val_loss, val_acc = validate(val_loader, model, criterion) log_res += [[train_loss, train_acc.cpu().numpy(),\ val_loss, val_acc.cpu().numpy()]] print( 'Epoch-{:<3d} {:.1f}s\t' 'Train: loss {:.4f}\taccu {:.4f}\tValid: loss {:.4f}\taccu {:.4f}' .format(epoch + 1, time.time() - t_start, train_loss, train_acc, val_loss, val_acc)) current = val_loss if mode == 'min' else val_acc ####### store tensor in cpu current = current.cpu() if monitor_op(current, best): print('Epoch %d: %s %sd from %.4f to %.4f, ' 'saving model to %s' % (epoch + 1, args.monitor, str_op, best, current, checkpoint)) best = current best_epoch = epoch + 1 save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best': best, 'monitor': args.monitor, 'optimizer': optimizer.state_dict(), }, checkpoint) earlystop_cnt = 0 else: print('Epoch %d: %s did not %s' % (epoch + 1, args.monitor, str_op)) earlystop_cnt += 1 scheduler.step() print('Best %s: %.4f from epoch-%d' % (args.monitor, best, best_epoch)) with open(csv_file, 'w') as fw: cw = csv.writer(fw) cw.writerow(['loss', 'acc', 'val_loss', 'val_acc']) cw.writerows(log_res) print('Save train and validation log into into %s' % csv_file) ### Test args.train = 0 model = SGN(args.num_classes, args.dataset, args.seg, args) model = model.cuda() test(test_loader, model, checkpoint, lable_path, pred_path)
def main(): # Training settings parser = argparse.ArgumentParser(description='CNN and Attention Network') parser.add_argument('--batch-size', type=int, default=16, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=21, metavar='N', help='number of epochs to train (default: 14)') parser.add_argument('--lr', type=float, default=1e-4, metavar='LR', help='learning rate (default: 1.0)') parser.add_argument('--gamma', type=float, default=0.7, metavar='M', help='Learning rate step gamma (default: 0.7)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument( '--intensity', type=str2bool, default=False, metavar='I', help='whether multilabel problem is treated as intensity or label') parser.add_argument( '--eval_mode', type=str2bool, default=False, metavar='E', help='whether evaluate the model only without training') parser.add_argument( '--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--fbank-train-path', type=str, help='the file of the fbank of training data',\ default="/home/jialu/disk1/Audio_Speech_Actors_01-24/train_fbank.h5") parser.add_argument('--emo-train-path', type=str, help='the file of the target of training data',\ default="/home/jialu/disk1/Audio_Speech_Actors_01-24/train_label.h5") parser.add_argument('--fbank-test-path', type=str, help='the file of the fbank of testing data',\ default="/home/jialu/disk1/Audio_Speech_Actors_01-24/test_fbank.h5") parser.add_argument('--emo-test-path', type=str, help='the file of the target of testing data',\ default="/home/jialu/disk1/Audio_Speech_Actors_01-24/test_label.h5") parser.add_argument('--load', type=str, default=None, help="Specify if want to load emotion model") parser.add_argument('--save', type=str, default=None, help='For Saving the emotion Model') args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} train_loader = torch.utils.data.DataLoader(dataset=util.dataset_h5( args.fbank_train_path, args.emo_train_path), collate_fn=util.collate_fn, batch_size=args.batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader(dataset=util.dataset_h5( args.fbank_test_path, args.emo_test_path), collate_fn=util.collate_fn, batch_size=1, shuffle=True, **kwargs) num_classes = util.get_num_classes(args.emo_test_path) model = Net(num_filters=384, num_classes=num_classes).to(device) model = load_pretrain_model(model, args.load, device) #train emotion classifier optimizer = optim.RMSprop(model.parameters(), lr=args.lr) scheduler = StepLR(optimizer, step_size=20, gamma=0.1) if args.eval_mode: test(args, model, device, test_loader) else: f1 = -1 for epoch in range(args.epochs): train(args, model, device, train_loader, optimizer, epoch) curr_f1, curr_f1_mac, curr_acc, curr_cm = test( args, model, device, test_loader) if curr_f1 > f1: f1 = curr_f1 f1_mac = curr_f1_mac acc = curr_acc cm = curr_cm best_epoch = epoch save_model(model, args.save) #hidden_nodes1,hidden_nodes2=model.get_hidden_nodes() print("epoch", best_epoch) print("Best accuracy is ", acc) print("Best F1 weighted score is ", f1) print("Best F1 macro score is ", f1_mac) print("Confusion matrix", cm)