def evaluate(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
print('The image is {:}'.format(args.image))
print('The model is {:}'.format(args.model))
snapshot = Path(args.model)
assert snapshot.exists(), 'The model path {:} does not exist'
facebox=face_detect(args.image,args.face_detector)
print('The face bounding box is {:}'.format(facebox))
assert len(facebox)==4,'Invalid face input : {:}'.format(facebox)
snapshot = torch.load(str(snapshot))
# General Data Argumentation
mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
param = snapshot['args']
eval_transform = transforms.Compose(
[transforms.PreCrop(param.pre_crop_expand), transforms.TrainScale2WH((param.crop_width, param.crop_height)),
transforms.ToTensor(), normalize])
model_config = load_configure(param.model_config, None)
dataset = GeneralDataset(eval_transform, param.sigma, model_config.downsample, param.heatmap_type, param.data_indicator)
dataset.reset(param.num_pts)
net = obtain_model(model_config, param.num_pts + 1)
net = net.cuda()
weights = remove_module_dict(snapshot['state_dict'])
net.load_state_dict(weights)
print('Prepare input data')
[image, _, _, _, _, _, cropped_size], meta = dataset.prepare_input(args.image, facebox)
inputs = image.unsqueeze(0).cuda()
# network forward
with torch.no_grad():
batch_heatmaps, batch_locs, batch_scos = net(inputs)
# obtain the locations on the image in the orignial size
cpu = torch.device('cpu')
np_batch_locs, np_batch_scos, cropped_size = batch_locs.to(cpu).numpy(), batch_scos.to(
cpu).numpy(), cropped_size.numpy()
locations, scores = np_batch_locs[0, :-1, :], np.expand_dims(np_batch_scos[0, :-1], -1)
scale_h, scale_w = cropped_size[0] * 1. / inputs.size(-2), cropped_size[1] * 1. / inputs.size(-1)
locations[:, 0], locations[:, 1] = locations[:, 0] * scale_w + cropped_size[2], locations[:, 1] * scale_h + \
cropped_size[3]
prediction = np.concatenate((locations, scores), axis=1).transpose(1, 0)
print('the coordinates for {:} facial landmarks:'.format(param.num_pts))
for i in range(param.num_pts):
point = prediction[:, i]
print('the {:02d}/{:02d}-th point : ({:.1f}, {:.1f}), score = {:.2f}'.format(i+1, param.num_pts, float(point[0]),
float(point[1]), float(point[2])))
image = draw_image_by_points(args.image, prediction, 2, (255, 0, 0), facebox, None,None)
image.show()
image.save(args.image.split('.')[0]+'_result.jpg')
def build_transforms(config):
transform_train = T.Compose([
T.RandomCroping(config.DATA.HEIGHT,
config.DATA.WIDTH,
p=config.AUG.RC_PROB),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
T.RandomErasing(probability=config.AUG.RE_PROB)
])
transform_test = T.Compose([
T.Resize((config.DATA.HEIGHT, config.DATA.WIDTH)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
return transform_train, transform_test
def initialize(self, dataset_opt):
self.phase = dataset_opt.phase
self.dir = dataset_opt.dataroot
if dataset_opt.use_subset:
subset_path = os.path.join(self.dir, 'subset.txt')
with open(subset_path) as f:
self.paths = [
os.path.join(self.dir, line.rstrip('\n')) for line in f
]
else:
self.paths = []
self.paths = get_image_paths_recursive(self.dir, self.paths)
self.size = len(self.paths)
self.transform_H = transforms.get_transform_H(dataset_opt.transform_H)
self.transform_L = transforms.get_transform_L(dataset_opt.transform_L)
self.to_tensor = transforms.ToTensor()
def train(self, signals, labels, sequences):
self.epoch_forward_init(signals, labels, sequences, True)
for i in range(self.epoch_iter_length):
signal, label, _ = self.queue.get()
self.step = float(i / self.epoch_iter_length + self.epoch)
self.optimizer.zero_grad()
signal, label = transforms.ToTensor(signal,
label,
gpu_id=self.opt.gpu_id)
output, loss = self.forward(signal, label)
self.epoch_loss += loss.item()
loss.backward()
self.optimizer.step()
self.load_poll_terminate()
self.opt.TBGlobalWriter.add_scalars(
'fold' + str(self.fold + 1) + '/loss',
{'train_loss': self.epoch_loss / (i + 1)}, self.step)
self.add_class_acc_to_tensorboard('train')
def eval(self, signals, labels, sequences):
self.epoch_forward_init(signals, labels, sequences, False)
for i in range(self.epoch_iter_length):
signal, label, sequence = self.queue.get()
self.eval_detail['sequences'].append(list(sequence))
self.eval_detail['ture_labels'].append(list(label))
signal, label = transforms.ToTensor(signal,
label,
gpu_id=self.opt.gpu_id)
with torch.no_grad():
output, loss = self.forward(signal, label)
self.epoch_loss += loss.item()
if self.opt.mode == 'autoencoder':
if (self.epoch + 1) % 10 == 0:
plot.draw_autoencoder_result(signal.data.cpu().numpy(),
output.data.cpu().numpy(),
self.opt)
plot.draw_scatter(self.features, self.opt)
else:
prec, reca, f1, err, kappa = statistics.report(self.confusion_mat)
print(
'epoch:' + str(self.epoch + 1),
' macro-prec,reca,F1,err,kappa: ' +
str(statistics.report(self.confusion_mat)))
self.add_class_acc_to_tensorboard('eval')
self.results['F1'].append(f1)
self.results['err'].append(err)
self.results['confusion_mat'].append(self.confusion_mat)
self.results['loss'].append(self.epoch_loss / (i + 1))
self.results['eval_detail'].append(self.eval_detail)
if self.opt.best_index == 'f1':
if f1 >= max(self.results['F1']):
self.results['best_epoch'] = self.epoch
elif self.opt.best_index == 'err':
if err <= min(self.results['err']):
self.results['best_epoch'] = self.epoch
self.load_poll_terminate()
self.opt.TBGlobalWriter.add_scalars(
'fold' + str(self.fold + 1) + '/loss',
{'eval_loss': self.epoch_loss / (i + 1)}, self.step)
self.epoch += 1
def get_transform(train, dataset_name):
base_size = cfg.DATA_TRANSFORM.LOADSIZE
crop_size = cfg.DATA_TRANSFORM.CROPSIZE
ignore_label = cfg.DATASET.IGNORE_LABEL
if dataset_name == cfg.DATASET.SOURCE:
input_size = cfg.DATA_TRANSFORM.INPUT_SIZE_S
else:
input_size = cfg.DATA_TRANSFORM.INPUT_SIZE_T
min_size = int((1.0 if train else 1.0) * base_size)
max_size = int((1.3 if train else 1.0) * base_size)
transforms = []
if cfg.DATA_TRANSFORM.RANDOM_RESIZE_AND_CROP:
if train:
transforms.append(T.RandomResize(min_size, max_size))
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(
T.RandomCrop(crop_size, ignore_label=ignore_label))
else:
transforms.append(T.Resize(cfg.DATA_TRANSFORM.INPUT_SIZE_T, True))
else:
if train:
transforms.append(T.Resize(input_size))
transforms.append(T.RandomHorizontalFlip(0.5))
else:
transforms.append(T.Resize(input_size, True))
mapping = get_label_map(cfg.DATASET.SOURCE, cfg.DATASET.TARGET)
transforms.append(T.LabelRemap(mapping[dataset_name]))
transforms.append(T.ToTensor(cfg.DATASET.IMG_MODE))
if cfg.DATASET.IMG_MODE == "BGR":
mean = (104.00698793, 116.66876762, 122.67891434)
std = (1.0, 1.0, 1.0)
else:
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
transforms.append(T.Normalize(mean, std))
return T.Compose(transforms)
def create_data_loader(mode, opt, shuffle=True):
if opt.dataset == 'SIDD_Tensor':
if mode == 'train':
csv_file_name = "train.txt"
cpu_transforms = []
if opt.patch_size != '-1':
cpu_transforms.append(_transforms.RandomCrop(opt.patch_size))
cpu_transforms.append(_transforms.ToTensor())
gpu_transforms = []
if opt.augs[0] != '-1':
for aug in opt.augs:
gpu_transforms.append(getattr(_transforms, aug)())
dataset = data_sets.SIDD_Tensor(
opt=opt,
csv_file_name=csv_file_name,
cpu_transform=transforms.Compose(cpu_transforms),
gpu_transform=transforms.Compose(gpu_transforms))
return DataLoader(dataset,
batch_size=opt.batch_size,
shuffle=shuffle,
num_workers=4,
pin_memory=True)
elif mode == 'test':
csv_file_name = "test.txt"
cpu_transforms = []
if opt.patch_size != '-1':
cpu_transforms.append(_transforms.RandomCrop(opt.patch_size))
cpu_transforms.append(_transforms.ToTensor())
dataset = data_sets.SIDD_Tensor(
opt=opt,
csv_file_name=csv_file_name,
cpu_transform=transforms.Compose(cpu_transforms),
manual_length=opt.test_set_length)
return DataLoader(dataset,
batch_size=1,
shuffle=shuffle,
num_workers=4,
pin_memory=True)
elif mode == 'validation':
dataset = data_sets.SIDD_Validation(
data_root=opt.sidd_validation_root,
gt_file_name='ValidationGtBlocksSrgb',
noisy_file_name='ValidationNoisyBlocksSrgb')
return DataLoader(dataset,
batch_size=1,
shuffle=shuffle,
num_workers=4,
pin_memory=True)
else:
raise Exception("dataloader mode incorrect")
else:
print("Dataset not found.")
return None
def main():
logging.basicConfig(filename='logs' + os.sep + 'example.log',
level=logging.DEBUG)
data_transforms = {
'train':
T.Compose([
T.ToOriginalHU(INTENSITY_OFFSET),
T.IntensityWindowing(WINDOWING),
T.SpacingResize(NORM_SPACING, MAX_SIZE),
T.ToTensor()
]),
'val':
T.Compose([
T.ToOriginalHU(INTENSITY_OFFSET),
T.IntensityWindowing(WINDOWING),
T.SpacingResize(NORM_SPACING, MAX_SIZE),
T.ToTensor()
]),
'test':
T.Compose([
T.ToOriginalHU(INTENSITY_OFFSET),
T.IntensityWindowing(WINDOWING),
T.SpacingResize(NORM_SPACING, MAX_SIZE),
T.ToTensor()
])
}
logging.info('Loading data sets')
image_datasets = {
x: DeepLesion(DIR_IN + os.sep + x, GT_FN_DICT[x], data_transforms[x])
for x in ['train', 'val', 'test']
}
logging.info('data sets loaded')
logging.info('Loading data loaders')
dl_dataloaders = {
x: DataLoader(image_datasets[x],
batch_size=3,
shuffle=True,
num_workers=0,
collate_fn=BatchCollator)
for x in ['train', 'val', 'test']
}
logging.info('data loaders loaded\n')
dl_dataset_sizes = {
x: len(image_datasets[x])
for x in ['train', 'val', 'test']
}
# for batch_id, (inputs, targets) in enumerate(dl_dataloaders['train']):
# i = 0
# for i, (image, target) in enumerate(zip(inputs, targets)):
# img_copy = image.squeeze().numpy()
# images = [img_copy] * 3
# images = [im.astype(float) for im in images]
# img_copy = cv2.merge(images)
# for j, (bbox, pseudo_mask) in enumerate(zip(target["boxes"], target["masks"])):
# bbox = target["boxes"][j].squeeze().numpy()
# bbox = np.int16(bbox)
# mask = target["masks"][j].squeeze().numpy()
# cv2.rectangle(img_copy, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 1)
# msk_idx = np.where(mask == 1)
# img_copy[msk_idx[0], msk_idx[1], 0] = 255
# cv2.imshow(str(batch_id) + " " + str(i), img_copy)
#
# cv2.waitKey(0)
# cv2.destroyAllWindows()
dl_model = get_model(False, True, 2)
params = [p for p in dl_model.parameters() if p.requires_grad]
# Observe that not all parameters are being optimized
optimizer_ft = SGD(params, lr=0.001, momentum=0.9, weight_decay=0.0001)
# optimizer_ft = Adam(params, lr=0.001)
# Decay LR by a factor of 0.1 every 7 epochs
# exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=4, gamma=0.1)
# exp_lr_scheduler = lr_scheduler.CosineAnnealingLR(optimizer_ft, T_max=100)
num_epochs = 10
since = time.time()
# best_model_wts = copy.deepcopy(dl_model.state_dict())
# best_llf = 0
# best_nlf = 999
logging.info('momentum:' +
str(optimizer_ft.state_dict()['param_groups'][0]['momentum']))
logging.info(
'weight_decay:' +
str(optimizer_ft.state_dict()['param_groups'][0]['weight_decay']))
# logging.info('LR decay gamma:' + str(exp_lr_scheduler.state_dict()['gamma']))
# logging.info('LR decay step size:' + str(exp_lr_scheduler.state_dict()['step_size']) + '\n')
for epoch in range(num_epochs):
# deep_copy_flag = False
logging.info('Epoch {}/{}'.format(epoch, num_epochs - 1))
logging.info('-' * 20)
train_one_epoc(dl_model, optimizer_ft, dl_dataloaders['train'],
dl_dataset_sizes['train'])
llf, nlf = evaluate(dl_model, dl_dataloaders['val'])
logging.info('LLF: {}'.format(llf))
logging.info('NLF: {}'.format(nlf) + '\n')
# exp_lr_scheduler.step()
# if llf > best_llf:
# deep_copy_flag = True
# best_nlf = nlf
# best_llf = llf
# elif (llf == best_llf) & (nlf < best_nlf):
# deep_copy_flag = True
# best_nlf = nlf
# if deep_copy_flag:
best_model_wts = copy.deepcopy(dl_model.state_dict())
torch.save(best_model_wts,
'saved_models' + os.sep + str(epoch) + '_deeplesion.pth')
time_elapsed = time.time() - since
logging.info('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
def main():
print('starting denoising')
noise_sigma = 4e-5 # sigma for the noise simulation
batch_size = 8 # number of images to run for each minibach
num_epochs = 200 # number of epochs to train
validation_seed = 15 # rng seed for validation loop
log_dir = 'logs/denoise/' # log dir for models and tensorboard
device = torch.device('cpu') # model will run on this device
dtype = torch.float # dtype for data and model
# set up tensorboard
writer = SummaryWriter(log_dir=log_dir)
# checkpoint file name
checkpoint_file = os.path.join(log_dir + 'best_model.pt')
# -------------------------------------------------------------------------
# NOISE SIMULATION SETUP
transform_list = [
transforms.AddNoise(target_op=False, sigma=noise_sigma),
transforms.Ifft(norm='ortho'),
transforms.SquareRootSumSquare(),
transforms.Normalize(),
transforms.ToTensor(dat_complex=False, target_complex=False)
]
# -------------------------------------------------------------------------
# DATALOADER SETUP
train_dataset = KneeDataSet('pytorch_tutorial_data/',
'train',
transform=transforms.Compose(transform_list))
print('data set information:')
print(train_dataset)
val_dataset = KneeDataSet('pytorch_tutorial_data/',
'val',
transform=transforms.Compose(transform_list))
# convert to a PyTorch dataloader
# this handles batching, random shuffling, parallelization
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=batch_size,
shuffle=True,
)
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=batch_size,
shuffle=True,
)
display_dat = val_dataset[15]['dat'].unsqueeze(0).to(device=device,
dtype=dtype)
display_target = val_dataset[15]['target'].unsqueeze(0).to(device=device,
dtype=dtype)
display_vmax = np.max(np.squeeze(display_dat.cpu().numpy()))
# -------------------------------------------------------------------------
# MODEL SETUP
model = DenoiseCnn(num_chans=64,
num_layers=4,
magnitude_input=True,
magnitude_output=True)
model = model.to(device)
model = model.train()
print('CNN model information:')
print(model)
# -------------------------------------------------------------------------
# OPTIMIZER SETUP
optimizer = torch.optim.Adam(model.parameters())
loss_fn = torch.nn.MSELoss()
# -------------------------------------------------------------------------
# LOAD PREVIOUS STATE
start_epoch, model, optimizer, min_val_loss = load_checkpoint(
checkpoint_file, model, optimizer)
current_seed = 20
# -------------------------------------------------------------------------
# NETWORK TRAINING
for epoch_index in range(start_epoch, num_epochs):
print('epoch {} of {}'.format(epoch_index + 1, num_epochs))
# ---------------------------------------------------------------------
# TRAINING LOOP
model = model.train()
# rng seed for noise generation
torch.manual_seed(current_seed)
np.random.seed(current_seed)
torch.cuda.manual_seed(current_seed)
# batch loop
losses = []
for batch in train_loader:
target = batch['target'].to(device=device, dtype=dtype)
dat = batch['dat'].to(device=device, dtype=dtype)
est = model(dat) # forward propagation
loss = loss_fn(est, target) # calculate the loss
optimizer.zero_grad() # clear out old gradients
loss.backward() # back propagation
optimizer.step() # update the CNN weights
# keep last 10 minibatches to compute training loss
losses.append(loss.item())
losses = losses[-10:]
print('trailing training loss: {}'.format(np.mean(losses)))
# ---------------------------------------------------------------------
# EVALUATION LOOP
model = model.eval()
# rng seed for noise generation
current_seed = np.random.get_state()[1][0]
torch.manual_seed(validation_seed)
np.random.seed(validation_seed)
torch.cuda.manual_seed(validation_seed)
# batch loop
val_losses = []
with torch.no_grad():
for batch in val_loader:
target = batch['target'].to(device=device, dtype=dtype)
dat = batch['dat'].to(device=device, dtype=dtype)
est = model(dat)
loss = loss_fn(est, target)
val_losses.append(loss.item())
print('validation loss: {}'.format(np.mean(val_losses)))
# ---------------------------------------------------------------------
# VISUALIZATIONS AND CHECKPOINTS
if np.mean(val_losses) < min_val_loss:
save_checkpoint(epoch_index, model, optimizer, np.mean(val_losses),
checkpoint_file)
# write the losses
writer.add_scalar('loss/train', np.mean(losses), epoch_index + 1)
writer.add_scalar('loss/validation', np.mean(val_losses),
epoch_index + 1)
# show an example image from the validation data
model = model.eval()
with torch.no_grad():
display_est = model(display_dat)
writer.add_image('validation/dat',
display_dat[0] / display_vmax,
global_step=epoch_index + 1)
writer.add_image('validation/cnn',
display_est[0] / display_vmax,
global_step=epoch_index + 1)
writer.add_image('validation/target',
display_target[0] / display_vmax,
global_step=epoch_index + 1)
writer.close()
saver = Saver(args)
saver.save_experiment_config()
# Define Tensorboard Summary
summary = TensorboardSummary(saver.experiment_dir)
args.exp = saver.experiment_dir.split('_')[-1]
if args.train_dataset == 'cityscapes':
# Data
train_trans = transforms.Compose([
transforms.ToPILImage(),
# transforms.RandomResizedCrop((args.image_size, args.image_size), scale=(0.2, 2)),
transforms.Resize((args.image_size, args.image_size)),
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(22, scale=(0.75, 1.25)),
transforms.ToTensor(),
transforms.Normalize(mean=[123.675, 116.28, 103.53],
std=[58.395, 57.12, 57.375])
# transforms.NormalizeInstance()
])
val_trans = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((args.image_size, args.image_size),
do_mask=False),
transforms.ToTensor(),
transforms.Normalize(mean=[123.675, 116.28, 103.53],
std=[58.395, 57.12, 57.375])
# transforms.NormalizeInstance()
])
if args.ann_type == 'comp':
def main(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
prepare_seed(args.rand_seed)
logstr = 'seed-{:}-time-{:}'.format(args.rand_seed, time_for_file())
logger = Logger(args.save_path, logstr)
logger.log('Main Function with logger : {:}'.format(logger))
logger.log('Arguments : -------------------------------')
for name, value in args._get_kwargs():
logger.log('{:16} : {:}'.format(name, value))
logger.log("Python version : {}".format(sys.version.replace('\n', ' ')))
logger.log("Pillow version : {}".format(PIL.__version__))
logger.log("PyTorch version : {}".format(torch.__version__))
logger.log("cuDNN version : {}".format(torch.backends.cudnn.version()))
# General Data Argumentation
mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
assert args.arg_flip == False, 'The flip is : {}, rotate is {}'.format(args.arg_flip, args.rotate_max)
train_transform = [transforms.PreCrop(args.pre_crop_expand)]
train_transform += [transforms.TrainScale2WH((args.crop_width, args.crop_height))]
train_transform += [transforms.AugScale(args.scale_prob, args.scale_min, args.scale_max)]
# if args.arg_flip:
# train_transform += [transforms.AugHorizontalFlip()]
if args.rotate_max:
train_transform += [transforms.AugRotate(args.rotate_max)]
train_transform += [transforms.AugCrop(args.crop_width, args.crop_height, args.crop_perturb_max, mean_fill)]
train_transform += [transforms.ToTensor(), normalize]
train_transform = transforms.Compose(train_transform)
eval_transform = transforms.Compose(
[transforms.PreCrop(args.pre_crop_expand), transforms.TrainScale2WH((args.crop_width, args.crop_height)),
transforms.ToTensor(), normalize])
assert (args.scale_min + args.scale_max) / 2 == args.scale_eval, 'The scale is not ok : {},{} vs {}'.format(
args.scale_min, args.scale_max, args.scale_eval)
# Model Configure Load
model_config = load_configure(args.model_config, logger)
args.sigma = args.sigma * args.scale_eval
logger.log('Real Sigma : {:}'.format(args.sigma))
# Training Dataset
train_data = GeneralDataset(train_transform, args.sigma, model_config.downsample, args.heatmap_type, args.data_indicator)
train_data.load_list(args.train_lists, args.num_pts, True)
train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size,
shuffle=True,num_workers=args.workers,
pin_memory=True)
# Evaluation Dataloader
eval_loaders = []
if args.eval_ilists is not None:
for eval_ilist in args.eval_ilists:
eval_idata = GeneralDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type,
args.data_indicator)
eval_idata.load_list(eval_ilist, args.num_pts, True)
eval_iloader = torch.utils.data.DataLoader(eval_idata, batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
eval_loaders.append((eval_iloader, False))
# Define network
logger.log('configure : {:}'.format(model_config))
net = obtain_model(model_config, args.num_pts + 1)
assert model_config.downsample == net.downsample, 'downsample is not correct : {} vs {}'.format(
model_config.downsample, net.downsample)
logger.log("=> network :\n {}".format(net))
logger.log('Training-data : {:}'.format(train_data))
for i, eval_loader in enumerate(eval_loaders):
eval_loader, is_video = eval_loader
logger.log('The [{:2d}/{:2d}]-th testing-data [{:}] = {:}'.format(i, len(eval_loaders),
'video' if is_video else 'image',
eval_loader.dataset))
logger.log('arguments : {:}'.format(args))
opt_config = load_configure(args.opt_config, logger)
if hasattr(net, 'specify_parameter'):
net_param_dict = net.specify_parameter(opt_config.LR, opt_config.Decay)
else:
net_param_dict = net.parameters()
optimizer, scheduler, criterion = obtain_optimizer(net_param_dict, opt_config, logger)
logger.log('criterion : {:}'.format(criterion))
net, criterion = net.cuda(), criterion.cuda()
net = torch.nn.DataParallel(net)
last_info = logger.last_info()
if last_info.exists():
logger.log("=> loading checkpoint of the last-info '{:}' start".format(last_info))
last_info = torch.load(str(last_info))
start_epoch = last_info['epoch'] + 1
checkpoint = torch.load(last_info['last_checkpoint'])
assert last_info['epoch'] == checkpoint['epoch'], 'Last-Info is not right {:} vs {:}'.format(last_info,
checkpoint[
'epoch'])
net.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
scheduler.load_state_dict(checkpoint['scheduler'])
logger.log("=> load-ok checkpoint '{:}' (epoch {:}) done".format(logger.last_info(), checkpoint['epoch']))
else:
logger.log("=> do not find the last-info file : {:}".format(last_info))
start_epoch = 0
if args.eval_once:
logger.log("=> only evaluate the model once")
eval_results = eval_all(args, eval_loaders, net, criterion, 'eval-once', logger, opt_config)
logger.close()
return
# Main Training and Evaluation Loop
start_time = time.time()
epoch_time = AverageMeter()
for epoch in range(start_epoch, opt_config.epochs):
scheduler.step()
need_time = convert_secs2time(epoch_time.avg * (opt_config.epochs - epoch), True)
epoch_str = 'epoch-{:03d}-{:03d}'.format(epoch, opt_config.epochs)
LRs = scheduler.get_lr()
logger.log('\n==>>{:s} [{:s}], [{:s}], LR : [{:.5f} ~ {:.5f}], Config : {:}'.format(time_string(), epoch_str,
need_time, min(LRs),
max(LRs), opt_config))
# train for one epoch
train_loss, train_nme = train(args, train_loader, net, criterion,
optimizer, epoch_str, logger, opt_config)
# log the results
logger.log(
'==>>{:s} Train [{:}] Average Loss = {:.6f}, NME = {:.2f}'.format(time_string(), epoch_str, train_loss,
train_nme * 100))
# remember best prec@1 and save checkpoint
save_path = save_checkpoint({
'epoch': epoch,
'args': deepcopy(args),
'arch': model_config.arch,
'state_dict': net.state_dict(),
'scheduler': scheduler.state_dict(),
'optimizer': optimizer.state_dict(),
}, str(logger.path('model') / '{:}-{:}.pth'.format(model_config.arch, epoch_str)), logger)
last_info = save_checkpoint({
'epoch': epoch,
'last_checkpoint': save_path,
}, str(logger.last_info()), logger)
eval_results = eval_all(args, eval_loaders, net, criterion, epoch_str, logger, opt_config)
# measure elapsed time
epoch_time.update(time.time() - start_time)
start_time = time.time()
logger.close()
def dann_train(self,
signals,
labels,
src_sequences,
dst_sequences,
beta=1.0,
stable=False):
self.epoch_forward_init(signals, labels, src_sequences, True)
dst_signals_len = len(dst_sequences)
domain_queue = Queue(self.opt.load_thread)
self.domain_random_loader_init(signals, labels, dst_sequences,
domain_queue)
domains = np.load(os.path.join(self.opt.dataset_dir, 'domains.npy'))
domains = dataloader.rebuild_domain(domains)
loss_show = [0, 0, 0]
for i in range(self.epoch_iter_length):
self.step = float(i / self.epoch_iter_length + self.epoch)
p = self.step / self.opt.epochs
if stable: alpha = beta
else: alpha = beta * (2. / (1. + np.exp(-10 * p)) - 1)
self.optimizer.zero_grad()
# src
s_signal, s_label, sequence = self.queue.get()
this_batch_len = s_signal.shape[0]
s_signal, s_label = transforms.ToTensor(s_signal,
s_label,
gpu_id=self.opt.gpu_id)
if self.opt.domain_num == 2:
s_domain = transforms.ToTensor(None,
np.zeros(this_batch_len,
dtype=np.int64),
gpu_id=self.opt.gpu_id)
else:
s_domain = transforms.batch_generator(None, domains, sequence)
s_domain = transforms.ToTensor(None,
s_domain,
gpu_id=self.opt.gpu_id)
# dst
d_signal, _, sequence = domain_queue.get()
d_signal = transforms.ToTensor(d_signal[:this_batch_len],
None,
gpu_id=self.opt.gpu_id)
if self.opt.domain_num == 2:
d_domain = transforms.ToTensor(None,
np.ones(this_batch_len,
dtype=np.int64),
gpu_id=self.opt.gpu_id)
else:
d_domain = transforms.batch_generator(
None, domains, sequence[:this_batch_len])
d_domain = transforms.ToTensor(None,
d_domain,
gpu_id=self.opt.gpu_id)
class_output, domain_output = self.net(s_signal, alpha=alpha)
self.add_label_to_confusion_mat(s_label, class_output, False)
loss_s_label = self.loss_dann_c(class_output, s_label)
loss_s_domain = self.loss_dann_d(domain_output, s_domain)
_, domain_output = self.net(d_signal, alpha=alpha)
loss_d_domain = self.loss_dann_d(domain_output, d_domain)
loss = loss_s_label + loss_s_domain + loss_d_domain
loss_show[0] += loss_s_label.item()
loss_show[1] += loss_s_domain.item()
loss_show[2] += loss_d_domain.item()
loss.backward()
self.optimizer.step()
self.add_class_acc_to_tensorboard('train')
self.opt.TBGlobalWriter.add_scalars(
'fold' + str(self.fold + 1) + '/loss', {
'src_label': loss_show[0] / (i + 1),
'src_domain': loss_show[1] / (i + 1),
'dst_domain': loss_show[2] / (i + 1)
}, self.step)
'''
@hypox64
2020/04/03
'''
opt = options.Options().getparse()
net,exp = creatnet.creatnet(opt)
#load data
signals = np.load('./datasets/simple_test/signals.npy')
labels = np.load('./datasets/simple_test/labels.npy')
#load prtrained_model
net.load_state_dict(torch.load('./checkpoints/pretrained/micro_multi_scale_resnet_1d_50class.pth'))
net.eval()
if self.opt.gpu_id != '-1' and len(self.opt.gpu_id) == 1:
self.net.cuda()
elif self.opt.gpu_id != '-1' and len(self.opt.gpu_id) > 1:
self.net = nn.DataParallel(self.net)
self.net.cuda()
for signal,true_label in zip(signals, labels):
signal = signal.reshape(1,1,-1).astype(np.float32) #batchsize,ch,length
true_label = true_label.reshape(1).astype(np.int64) #batchsize
signal,true_label = transforms.ToTensor(signal,true_label,gpu_id =opt.gpu_id)
out = net(signal)
pred_label = torch.max(out, 1)[1]
pred_label=pred_label.data.cpu().numpy()
true_label=true_label.data.cpu().numpy()
print(("true:{0:d} predict:{1:d}").format(true_label[0],pred_label[0]))
