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)