def __init__(self, num_classes: int):
"""
:param num_classes:
"""
super(ViTBase16, self).__init__()
self.model = create_model('vit_base_patch16_384', num_classes=num_classes, pretrained=False)
def __init__(self, num_classes: int):
"""
:param num_classes: int
"""
super(Efficient_b6, self).__init__()
self.model = create_model('tf_efficientnet_b6_ns', num_classes=num_classes, pretrained=True)
def __init__(self, num_classes: int):
super().__init__()
self.model = create_model('resnet200d', pretrained=False)
n_features = self.model.fc.in_features
self.model.global_pool = nn.Identity()
self.model.fc = nn.Identity()
self.pooling = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Linear(n_features, num_classes)
import os
from options.test_options import TestOptions
from dataloader.data_loader import dataloader
from model.models import create_model
from util.visualizer import Visualizer
from util import html
opt = TestOptions().parse()
dataset = dataloader(opt)
dataset_size = len(dataset) * opt.batchSize
print ('testing images = %d ' % dataset_size)
model = create_model(opt)
visualizer = Visualizer(opt)
web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' %(opt.phase, opt.which_epoch))
web_page = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.which_epoch))
# testing
for i,data in enumerate(dataset):
model.set_input(data)
model.test()
model.save_results(visualizer, web_page)
parser.add_argument(
'--model_size_info',
type=int,
nargs="+",
default=[1, 100],
help='Model dimensions - different for various models')
args = parser.parse_args()
model_settings = models.prepare_model_settings(
len(input_data.prepare_words_list(args.wanted_words.split(','))),
args.sample_rate, args.clip_duration_ms, args.window_size_ms,
args.window_stride_ms, args.dct_coefficient_count)
print(model_settings)
model = models.create_model(model_settings, args.arch, args.model_size_info)
model.cuda()
model_path = os.path.join(args.save_dir, args.load_model_name)
print(model_path)
model.load_state_dict(torch.load(model_path)["state_dict"],strict=False)#i modify here
for name, weight in model.named_parameters():
print (name)
unique, counts = np.unique((weight.cpu().detach().numpy()).flatten(), return_counts=True)
un_list = np.asarray((unique, counts)).T
print("Unique quantized weights counts:\n", un_list)
print(len(un_list))
dataset = dataloader(opt)
dataset_size = len(dataset) * opt.batch_size
print('training images = %d' % dataset_size)
# create datasets for Gaussian Process
labeled_dataset = None
unlabeled_dataset = None
if opt.gp:
labeled_dataset, unlabeled_dataset = dataloader(opt, gp=True)
print('The number of labeled training images for GP = %d' %
len(labeled_dataset))
print('The number of unlabeled training images for GP = %d' %
len(unlabeled_dataset))
model = create_model(opt, labeled_dataset, unlabeled_dataset)
visualizer = Visualizer(opt)
total_steps = 0
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
epoch_iter = 0
# training
for i, data in enumerate(dataset):
iter_start_time = time.time()
total_steps += opt.batch_size
epoch_iter += opt.batch_size
model.set_input(data)
model.optimize_parameters(i)
import time
from options.train_options import TrainOptions
from dataloader.data_loader import dataloader
from model.models import create_model
from util.visualizer import Visualizer
opt = TrainOptions().parse()
dataset = dataloader(opt)
dataset_size = len(dataset) * opt.batchSize
print('training images = %d' % dataset_size)
s_model, t_model = create_model(opt)
visualizer = Visualizer(opt)
total_steps = 0
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
epoch_iter = 0
# training
for i, data in enumerate(dataset):
iter_start_time = time.time()
total_steps += opt.batchSize
epoch_iter += opt.batchSize
model.set_input(data)
model.optimize_parameters(i)
if total_steps % opt.display_freq == 0:
if epoch >= opt.transform_epoch:
model.validation_target()
# parser.add_argument("--log", type=str, default='', help="Training log file")
# parser.add_argument("--saved_model_file", type=str, default='', help="Saved trainde models")
# parser.add_argument("--checkpoint", type=str, default='', help="Load chenkpoint")
args = parser.parse_args()
csv_file = './five_folders/' + args.csv_file + '/{}.csv'
root_dir = '/home/gtwell/all_images/dataset'
out = create_dataset(csv_file=csv_file,
root_dir=root_dir,
img_size=args.img_size,
batch_size=args.batch_size)
dataloaders = out['dataloaders']
dataset_sizes = out['dataset_sizes']
use_gpu = torch.cuda.is_available()
model_conv = create_model(model_key=args.model,
pretrained=eval(args.pretrained),
num_of_classes=6,
use_gpu=use_gpu)
criterion = nn.CrossEntropyLoss()
# Observe that only parameters of final layer are being optimized as
# opoosed to before.
if eval(args.pretrained):
parameters_totrain = model_conv.fc.parameters()
else:
parameters_totrain = model_conv.parameters()
# Choose optimizer for training
if args.optimizer == 'SGD':
optimizer_conv = optim.SGD(parameters_totrain, lr=0.001, momentum=0.9)
elif args.optimizer == 'Adam':
data_dir=cfg.DATA_DIR_TRAIN,
transform=transforms.Compose(train_transforms))
val_dataset = conc_dataset.AlignedConcDataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose(val_transforms))
train_loader = DataProvider(cfg, dataset=train_dataset)
val_loader = DataProvider(cfg, dataset=val_dataset, shuffle=False)
# class weights
num_classes_train = list(
Counter([i[1] for i in train_loader.dataset.imgs]).values())
cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train)
writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard
model = create_model(cfg, writer)
model.set_data_loader(train_loader, val_loader, unlabeled_loader)
def train():
print('>>> task path is {0}'.format(project_name))
# train
model.train_parameters(cfg)
print('save model ...')
model_filename = '{0}_{1}_finish.pth'.format(cfg.MODEL,
cfg.WHICH_DIRECTION)
model.save_checkpoint(cfg.NITER_TOTAL, model_filename)
def main():
global config, best_prec1
args = parser.parse_known_args()[0].__dict__
config = Config()
for key, value in args.items():
if value is not None:
setattr(config, key, value)
if config.logger:
logging.basicConfig(level=logging.INFO, format='%(message)s')
logger = logging.getLogger()
try:
os.makedirs("logger", exist_ok=True)
except TypeError:
raise Exception("Direction not create!")
logger.addHandler(
logging.FileHandler(
strftime('logger/GSC_%m-%d-%Y-%H:%M_id_') + str(uuid.uuid4()) +
'.log', 'a'))
global print
print = logger.info
use_cuda = not config.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# Check the save_dir exists or not
if not os.path.exists(config.save_dir):
os.makedirs(config.save_dir)
print("Current network is {}".format(config.arch))
# Start a new TensorFlow session.
sess = tf.InteractiveSession()
# Begin by making sure we have the training data we need. If you already have
# training data of your own, use `--data_url= ` on the command line to avoid
# downloading.
model_settings = models.prepare_model_settings(
len(input_data.prepare_words_list(config.wanted_words.split(','))),
config.sample_rate, config.clip_duration_ms, config.window_size_ms,
config.window_stride_ms, config.dct_coefficient_count)
print(model_settings)
time_shift_samples = int(
(config.time_shift_ms * config.sample_rate) / 1000)
train_loader = torch.utils.data.DataLoader(GSCDataset(
config.data_url,
config.data_dir,
config.silence_percentage,
config.unknown_percentage,
config.wanted_words.split(','),
config.validation_percentage,
config.testing_percentage,
model_settings,
sess,
config.arch,
mode="training",
background_frequency=config.background_frequency,
background_volume_range=config.background_frequency,
time_shift=time_shift_samples),
shuffle=True,
batch_size=config.batch_size,
num_workers=config.workers)
print("train set size: {}".format(len(train_loader.dataset)))
val_loader = torch.utils.data.DataLoader(GSCDataset(
config.data_url,
config.data_dir,
config.silence_percentage,
config.unknown_percentage,
config.wanted_words.split(','),
config.validation_percentage,
config.testing_percentage,
model_settings,
sess,
config.arch,
mode="validation"),
batch_size=config.batch_size,
num_workers=config.workers)
print("validation set size: {}".format(len(val_loader.dataset)))
test_loader = torch.utils.data.DataLoader(GSCDataset(
config.data_url,
config.data_dir,
config.silence_percentage,
config.unknown_percentage,
config.wanted_words.split(','),
config.validation_percentage,
config.testing_percentage,
model_settings,
sess,
config.arch,
mode="testing"),
batch_size=config.batch_size,
num_workers=config.workers)
print("test set size: {}".format(len(test_loader.dataset)))
model = models.create_model(config, model_settings)
model.cuda()
if config.resume:
if os.path.isfile(config.resume):
print("=> loading checkpoint '{}'".format(config.resume))
checkpoint = torch.load(config.resume)
try:
model.load_state_dict(checkpoint)
except:
print("Trying load with dict 'state_dict'")
# try:
# if not config.admm_quant:
# model.set_alpha(checkpoint['alpha'])
model.load_state_dict(checkpoint['state_dict'])
# except:
# print("Cann't load model")
# return
else:
print("=> no checkpoint found at '{}'".format(config.resume))
return
cudnn.benchmark = True
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
if config.optimizer_type == "sgd":
optimizer = torch.optim.SGD(model.parameters(),
config.lr,
momentum=config.momentum,
weight_decay=config.weight_decay,
nesterov=True)
elif config.optimizer_type == "adam":
optimizer = torch.optim.Adam(model.parameters(),
config.lr,
weight_decay=config.weight_decay)
elif config.optimizer_type == "adamw":
optimizer = AdamW(model.parameters(),
lr=config.lr,
weight_decay=config.weight_decay)
elif config.optimizer_type == "rmsprop":
optimizer = torch.optim.RMSprop(model.parameters(),
config.lr,
weight_decay=config.weight_decay)
elif config.optimizer_type == "adagrad":
optimizer = torch.optim.Adagrad(model.parameters(),
config.lr,
weight_decay=config.weight_decay)
elif config.optimizer_type == "adadelta":
optimizer = torch.optim.Adadelta(model.parameters(),
config.lr,
weight_decay=config.weight_decay)
else:
raise ValueError("The optimizer type is not defined!")
if config.evaluate:
# validate(val_loader, model, criterion)
val_acc = validate_by_step(config, val_loader, model, criterion,
model_settings, sess)
# test(test_loader, model, criterion)
test_acc = test_by_step(config, test_loader, model, criterion,
model_settings, sess)
return
if config.admm_quant:
pass
# name_list = []
# for name, w in model.named_parameters():
# if "weight" or "bias" in name:
# name_list.append(name)
# print("Quantized Layer name list is :")
# print(", ".join(name_list))
# print("Before quantized:")
# validate_by_step(config, audio_processor, model, criterion, model_settings, sess)
# admm.admm_initialization(config, model, device, name_list, print)
# print("After quantized:")
# validate_quant_by_step(config, audio_processor, model, criterion, model_settings,
# sess, name_list, device)
# for epoch in range(config.start_epoch, config.epochs):
# if config.lr_scheduler == 'default':
# adjust_learning_rate(optimizer, epoch)
# elif config.lr_scheduler == 'cosine':
# pass
# admm_quant_train_by_step(config, audio_processor, model, criterion, optimizer, epoch, model_settings,
# time_shift_samples, sess, name_list, device)
# # evaluate on validation set
# print("After Quantized:")
# prec1, quantized_model = validate_quant_by_step(config, audio_processor, model, criterion, model_settings,
# sess, name_list, device)
# # remember best prec@1 and save checkpoint
# is_best = prec1 > best_prec1
# if is_best:
# path_name = os.path.join(config.save_dir,
# '{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}.pt'.format(
# arch=config.arch,
# type=config.quant_type, num_bits=config.num_bits,
# prec1=best_prec1))
# new_path_name = os.path.join(config.save_dir,
# '{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}.pt'.format(
# arch=config.arch, type=config.quant_type, num_bits=config.num_bits,
# prec1=prec1))
# if os.path.isfile(path_name):
# os.remove(path_name)
# best_prec1 = prec1
# save_checkpoint(quantized_model, new_path_name)
# print("Admm training, best top 1 acc {best_prec1:.3f}".format(best_prec1=best_prec1))
# print("Best testing dataset:")
# test_by_step(config, audio_processor, quantized_model, criterion, model_settings, sess)
# else:
# print("Admm training, best top 1 acc {best_prec1:.3f}, current top 1 acc {prec1:.3f}".format(
# best_prec1=best_prec1, prec1=prec1))
else:
for epoch in range(0, config.epochs):
if config.lr_scheduler == 'default':
adjust_learning_rate(optimizer, epoch)
elif config.lr_scheduler == 'cosine':
pass
# scheduler.step()
# train for one epoch
train_by_step(config, train_loader, model, criterion, optimizer,
epoch, model_settings, time_shift_samples, sess)
# evaluate on validation set
# prec1 = validate(val_loader, model, criterion)
prec1 = validate_by_step(config, val_loader, model, criterion,
model_settings, sess)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
if is_best:
path_name = os.path.join(
config.save_dir,
'{arch}_GSC_acc_{prec1:.3f}.pt'.format(arch=config.arch,
prec1=best_prec1))
new_path_name = os.path.join(
config.save_dir,
'{arch}_GSC_acc_{prec1:.3f}.pt'.format(arch=config.arch,
prec1=prec1))
if os.path.isfile(path_name):
os.remove(path_name)
best_prec1 = prec1
save_checkpoint(model, new_path_name)
print(
"Current best validation accuracy {best_prec1:.3f}".format(
best_prec1=best_prec1))
else:
print("Current validation accuracy {prec1:.3f}, "
"best validation accuracy {best_prec1:.3f}".format(
prec1=prec1, best_prec1=best_prec1))
# test(test_loader, model, criterion)
test_by_step(config, test_loader, model, criterion, model_settings,
sess)
def validate_quant_by_step(config, audio_processor, model, criterion,
model_settings, sess, name_list, device):
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
quantized_model = models.create_model(config, model_settings)
quantized_model.alpha = model.alpha
quantized_model.Q = model.Q
quantized_model.Z = model.Z
quantized_model.load_state_dict(model.state_dict())
quantized_model.cuda()
admm.apply_quantization(config, quantized_model, name_list, device)
quantized_model.eval()
valid_set_size = audio_processor.set_size('validation')
max_step_epoch = valid_set_size // config.batch_size
input_frequency_size = model_settings[
'dct_coefficient_count'] # sequence length 10
input_time_size = model_settings['spectrogram_length'] # input_size 25
end = time.time()
for i in range(0, valid_set_size, config.batch_size):
input, target = audio_processor.get_data(config.batch_size, i,
model_settings, 0.0, 0.0, 0,
'validation', sess)
target = torch.Tensor(target).cuda()
_, target = target.max(dim=1)
target = target.cuda()
input = input.reshape((-1, input_time_size, input_frequency_size))
input = torch.Tensor(input).cuda()
with torch.no_grad():
input_var = torch.autograd.Variable(input.float()).cuda()
target_var = torch.autograd.Variable(target.long())
# compute output
output = quantized_model(input_var)
loss = criterion(output, target_var)
output = output.float()
loss = loss.float()
# measure accuracy and record loss
prec1 = accuracy(output.data, target)[0]
losses.update(loss.data, input.size(0))
top1.update(prec1, input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if (i // config.batch_size) % config.print_freq == 0:
print('Validation: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
i // config.batch_size,
max_step_epoch,
batch_time=batch_time,
loss=losses,
top1=top1))
print(' * Prec@1 {top1.avg:.3f}'.format(top1=top1))
return top1.avg, quantized_model
def main():
global args, best_prec1
args = parser.parse_args()
args.save_name = 'loushu'
if args.logger:
logging.basicConfig(level=logging.INFO, format='%(message)s')
logger = logging.getLogger()
try:
os.makedirs("logger", exist_ok=True)
except TypeError:
raise Exception("Direction not create!")
logger.addHandler(
logging.FileHandler(
strftime('logger/GSC_%m-%d-%Y-%H:%M_id_') + str(uuid.uuid4()) +
'.log', 'a'))
global print
print = logger.info
print("The config arguments showed as below:")
print(args)
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# Check the save_dir exists or not
if not os.path.exists(args.save_dir):
os.makedirs(args.save_dir)
print("Current network is {}".format(args.arch))
# Start a new TensorFlow session.
sess = tf.InteractiveSession()
# Begin by making sure we have the training data we need. If you already have
# training data of your own, use `--data_url= ` on the command line to avoid
# downloading.
model_settings = models.prepare_model_settings(
len(input_data.prepare_words_list(args.wanted_words.split(','))),
args.sample_rate, args.clip_duration_ms, args.window_size_ms,
args.window_stride_ms, args.dct_coefficient_count)
print(model_settings)
audio_processor = input_data.AudioProcessor(args.data_url, args.data_dir,
args.silence_percentage,
args.unknown_percentage,
args.wanted_words.split(','),
args.validation_percentage,
args.testing_percentage,
model_settings)
# fingerprint_size = model_settings['fingerprint_size']
# label_count = model_settings['label_count']
# train_set_size = audio_processor.set_size('training')
# print('set_size=%d', train_set_size)
# valid_set_size = audio_processor.set_size('validation')
# print('set_size=%d', valid_set_size)
time_shift_samples = int((args.time_shift_ms * args.sample_rate) / 1000)
# train_loader = torch.utils.data.DataLoader(
# GSCDataset(args.data_url, args.data_dir, args.silence_percentage, args.unknown_percentage,
# args.wanted_words.split(','), args.validation_percentage, args.testing_percentage,
# model_settings, sess, args.arch, mode="training", background_frequency=args.background_frequency,
# background_volume_range=args.background_frequency, time_shift=time_shift_samples), shuffle=True,
# batch_size=args.batch_size, num_workers=args.workers)
# print("train set size: {}".format(len(train_loader.dataset)))
val_loader = torch.utils.data.DataLoader(GSCDataset(
args.data_url,
args.data_dir,
args.silence_percentage,
args.unknown_percentage,
args.wanted_words.split(','),
args.validation_percentage,
args.testing_percentage,
model_settings,
sess,
args.arch,
mode="validation"),
batch_size=args.batch_size,
num_workers=args.workers)
print("validation set size: {}".format(len(val_loader.dataset)))
test_loader = torch.utils.data.DataLoader(GSCDataset(
args.data_url,
args.data_dir,
args.silence_percentage,
args.unknown_percentage,
args.wanted_words.split(','),
args.validation_percentage,
args.testing_percentage,
model_settings,
sess,
args.arch,
mode="testing"),
batch_size=args.batch_size,
num_workers=args.workers)
print("test set size: {}".format(len(test_loader.dataset)))
#model = models.create_model(model_settings, args.arch, args.model_size_info)
model = models.create_model(model_settings, args.arch,
args.model_size_info, args.save_act_value,
args.save_act_dir)
model.cuda()
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume, map_location='cuda:0')
try:
model.load_state_dict(checkpoint)
except:
print("Trying load with dict 'state_dict'")
try:
model.load_state_dict(checkpoint['state_dict'])
except:
print("Cann't load model")
return
else:
print("=> no checkpoint found at '{}'".format(args.resume))
return
cudnn.benchmark = True
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
if args.optimizer_type == "sgd":
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
elif args.optimizer_type == "adam":
optimizer = torch.optim.Adam(model.parameters(),
args.lr,
weight_decay=args.weight_decay)
elif args.optimizer_type == "adamw":
optimizer = AdamW(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
elif args.optimizer_type == "rmsprop":
optimizer = torch.optim.RMSprop(model.parameters(),
args.lr,
weight_decay=args.weight_decay)
elif args.optimizer_type == "adagrad":
optimizer = torch.optim.Adagrad(model.parameters(),
args.lr,
weight_decay=args.weight_decay)
elif args.optimizer_type == "adadelta":
optimizer = torch.optim.Adadelta(model.parameters(),
args.lr,
weight_decay=args.weight_decay)
else:
raise ValueError("The optimizer type is not defined!")
if args.evaluate:
# validate(val_loader, model, criterion)
validate_by_step(args, audio_processor, model, criterion,
model_settings, sess)
#test(test_loader, model, criterion)
test_by_step(args, audio_processor, model, criterion, model_settings,
sess)
return
# scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs * len(train_loader),
# eta_min=4e-08)
if args.admm_quant:
name_list = []
for name, w in model.named_parameters():
if "weight" or "bias" in name:
name_list.append(name)
print("Quantized Layer name list is :")
print(", ".join(name_list))
print("Before quantized:")
validate_by_step(args, audio_processor, model, criterion,
model_settings, sess)
admm.admm_initialization(args, model, device, name_list, print)
print("After quantized:")
validate_quant_by_step(args, audio_processor, model, criterion,
model_settings, sess, name_list, device)
for epoch in range(args.start_epoch, args.epochs):
if args.lr_scheduler == 'default':
adjust_learning_rate(optimizer, epoch)
elif args.lr_scheduler == 'cosine':
pass
admm_quant_train_by_step(args, audio_processor, model, criterion,
optimizer, epoch, model_settings,
time_shift_samples, sess, name_list,
device)
# evaluate on validation set
print("After Quantized:")
prec1, quantized_model = validate_quant_by_step(
args, audio_processor, model, criterion, model_settings, sess,
name_list, device)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
if is_best:
path_name = os.path.join(
args.save_dir,
'{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}_{add}.pt'
.format(arch=args.arch,
type=args.quant_type,
num_bits=args.num_bits,
prec1=best_prec1,
add=args.save_name))
new_path_name = os.path.join(
args.save_dir,
'{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}_{add}.pt'
.format(arch=args.arch,
type=args.quant_type,
num_bits=args.num_bits,
prec1=prec1,
add=args.save_name))
if os.path.isfile(path_name):
os.remove(path_name)
best_prec1 = prec1
save_checkpoint(quantized_model, new_path_name)
print("Admm training, best top 1 acc {best_prec1:.3f}".format(
best_prec1=best_prec1))
print("Best testing dataset:")
test_by_step(args, audio_processor, quantized_model, criterion,
model_settings, sess)
else:
print(
"Admm training, best top 1 acc {best_prec1:.3f}, current top 1 acc {prec1:.3f}"
.format(best_prec1=best_prec1, prec1=prec1))
else:
for epoch in range(args.start_epoch, args.epochs):
if args.lr_scheduler == 'default':
adjust_learning_rate(optimizer, epoch)
elif args.lr_scheduler == 'cosine':
pass
# scheduler.step()
# train for one epoch
train_by_step(args, audio_processor, model, criterion, optimizer,
epoch, model_settings, time_shift_samples, sess)
# evaluate on validation set
# prec1 = validate(val_loader, model, criterion)
prec1 = validate_by_step(args, audio_processor, model, criterion,
model_settings, sess)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
if is_best:
path_name = os.path.join(
args.save_dir,
'{arch}_GSC_acc_{prec1:.3f}_{add}.pt'.format(
arch=args.arch, prec1=best_prec1, add=args.save_name))
new_path_name = os.path.join(
args.save_dir,
'{arch}_GSC_acc_{prec1:.3f}_{add}.pt'.format(
arch=args.arch, prec1=prec1, add=args.save_name))
if os.path.isfile(path_name):
os.remove(path_name)
best_prec1 = prec1
save_checkpoint(model, new_path_name)
print(
"Current best validation accuracy {best_prec1:.3f}".format(
best_prec1=best_prec1))
else:
print("Current validation accuracy {prec1:.3f}, "
"best validation accuracy {best_prec1:.3f}".format(
prec1=prec1, best_prec1=best_prec1))
# test(test_loader, model, criterion)
test_by_step(args, audio_processor, model, criterion, model_settings,
sess)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--yaml-config', type=str, default='simg_bmi_regression_3.6.6.2_nfs.yaml')
parser.add_argument('--run-train', type=str, default='True')
parser.add_argument('--run-test', type=str, default='False')
parser.add_argument('--run-grad-cam', type=str, default='False')
parser.add_argument('--train-fold', type=int, default=0)
args = parser.parse_args()
SRC_ROOT = os.path.dirname(os.path.realpath(__file__)) + '/..'
yaml_config = os.path.join(SRC_ROOT, f'src/yaml/{args.yaml_config}')
logger.info(f'Read yaml file {yaml_config}')
f = open(yaml_config, 'r').read()
config = yaml.safe_load(f)
out_folder = config['exp_dir']
learning_rate = config['learning_rate']
batch_size = config['batch_size']
epoch_num = config['epoch_num']
fold_num = config['fold_num']
mkdir_p(out_folder)
# load CUDA
cuda = torch.cuda.is_available()
print(f'cuda: {cuda}')
# cuda = False
torch.manual_seed(1)
# Create data loader
train_loader_list, valid_loader_list, test_loader_list = get_data_loader_cv(config)
# Create trainer list
performance_array = []
for idx_fold in range(fold_num):
# If train only one fold
if args.train_fold != -1:
# Only train on specified fold.
if args.train_fold != idx_fold:
continue
# Create model
model = create_model(config)
if cuda:
torch.cuda.manual_seed(1)
model = model.cuda()
# load optimizor
optim = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999))
# Create trainer
fold_out_folder = os.path.join(out_folder, f'fold_{idx_fold}')
train_loader = train_loader_list[idx_fold]
validate_loader = valid_loader_list[idx_fold]
test_loader = test_loader_list[idx_fold]
trainer_obj = Trainer(
cuda,
model,
optimizer=optim,
train_loader=train_loader,
validate_loader=validate_loader,
test_loader=test_loader,
out=fold_out_folder,
max_epoch=epoch_num,
batch_size=batch_size,
config=config
)
# Train
trainer_obj.epoch = config['start_epoch']
if args.run_train == 'True':
trainer_obj.train_epoch()
# Test
if args.run_test == 'True':
trainer_obj.run_test()
performance_array.append(trainer_obj.test_performance)
if args.run_grad_cam == 'True':
trainer_obj.run_grad_cam()
if args.run_test == 'True':
mse_array = np.array([statics_dict['loss'] for statics_dict in performance_array])
rmse_array = np.sqrt(mse_array)
rmse_mean = np.mean(rmse_array)
rmse_std = np.std(rmse_array)
perf_str = f'RMSE {rmse_mean:.5f} ({rmse_std:.5f})\n'
print(f'Performance of cross-validation:')
print(perf_str)
perf_file = os.path.join(out_folder, 'perf')
with open(perf_file, 'w') as fv:
fv.write(perf_str)
fv.close()
