def prepare(model_ids, dataset_name):
"""
Args:
model_ids: list of str - ids of models for inference
dataset_name: str - will construct validation loader of the dataset
! Important:
models are expected to have same settings regarding dataset and training (eg roi, input res)
Returns:
loaded models ready for inference in a list
validation_loader
params
"""
models, params_list, configs_list = [], [], []
for id in model_ids:
params = Params(constants.params_path.format(dataset_name, id))
config = Params(constants.config_path.format(dataset_name, id))
validate_params(params)
print("Constructing model: ", id)
model = training_setup.model_setup(params, config)
# in this case, model id is equal to exp name
training_setup.load_model_weights(model, dataset_name, id)
model.eval()
prints.print_trained_parameters_count(model)
models.append(model)
params_list.append(params)
configs_list.append(config)
if len(model_ids) == 1:
return models[0], params_list[0], configs_list[0]
return models, params_list, configs_list
def test_sampler():
dt1 = EvMaskPoseDataset(1, Params())
dt2 = EvMaskPoseDataset(2, Params())
dt3 = EvMaskPoseDataset(3, Params())
dt4 = EvMaskPoseDataset(4, Params())
cdt = ConcatDataset([dt1, dt2, dt3, dt4])
custom_sampler = ConcatDataSampler(cdt, 4, True)
assert len(custom_sampler) == len(cdt) // 4
for n in custom_sampler:
assert n is not None
def save_predictions_test(predicted_volumes, model_id, dataset_name):
"""
list of ndarrays representing volume predictions
"""
config = Params(constants.config_path.format(dataset_name, model_id))
params = Params(constants.params_path.format(dataset_name, model_id))
test_dataloader = training_setup.prepare_test_loader(params, config)
for batch_idx, (volume, orig_shape, header_info, img_path) in enumerate(test_dataloader):
print("Volume shape: ", volume.shape, " and original shape: ", orig_shape)
processed_volume = predicted_volumes[batch_idx]
save_volume(processed_volume, header_info, batch_idx, img_path=img_path)
print("Volume number ", batch_idx+1, " saved successfully!")
def save_predictions(predicted_volumes, model_id, dataset_name):
"""
list of ndarrays representing volume predictions
"""
config = Params(constants.config_path.format(dataset_name, model_id))
params = Params(constants.params_path.format(dataset_name, model_id))
validation_dataloader = training_setup.prepare_val_loader(params, config)
for batch_idx, (_, mask, _, header_info) in enumerate(validation_dataloader):
mask = mask.numpy().astype(np.uint8)
processed_volume = predicted_volumes[batch_idx]
save_volume(processed_volume, header_info, batch_idx)
save_volume(mask, header_info, batch_idx, type="gt")
print("Volume number ", batch_idx+1, " saved successfully!")
def target(self, index):
from init import init_uv
from iterations import run
X, C, labels = load_dataset(self.dataset)
U, V = init_uv(X, C, Params(dict(**self.init_params, **self.mutual)))
initial = {name: (U.copy(), V.copy()) for name in self.params}
result = {}
for name, param in self.params.items():
p = Params({
**param,
**self.mutual, 'initial': initial[name],
'init': 'preset',
'C': C
})
dest = os.path.join(self.root_directory, name + '.h5.' +
str(index)) if self.root_directory else ''
print('running', name)
logger = Logger(dest)
start_time = time()
result = run(X, labels, p, logger)
end_time = time()
time_elasped = end_time - start_time
result = (*result, time_elasped)
print(name, result[2:])
logger.log_final(*result)
logger.close()
return result
def data():
from init import init_uv
from utils.datasets import load_dataset
from utils.params import Params
X, C, labels = load_dataset('mnist_10k')
return (
X,
*init_uv(
X, C,
Params({
'method': 'random'
})
),
labels
)
def __init__(self, data_dir, params):
"""
Loads dataset_params, vocabulary and tags. Ensure you have run
`build_vocab.py` on data_dir before using this class.
Parameters
----------
data_dir: (string) directory containing the dataset
params: (Params) hyperparameters of the training process. This function
modifies params and appends dataset_params (such as vocab_size,
num_of_tags etc.) to params.
"""
# loading dataset_params
json_path = os.path.join(data_dir, 'dataset_params.json')
if not os.path.isfile(json_path):
raise ValueError(
"No json file found at {}, run build_vocab.py".format(
json_path))
self.dataset_params = Params(json_path)
# loading vocab (we require this to map words to their indices)
vocab_path = os.path.join(data_dir, 'words.txt')
self.vocab = {}
with open(vocab_path) as f:
for i, l in enumerate(f.read().splitlines()):
self.vocab[l] = i
# setting the indices for UNKnown words and PADding symbols
self.unk_ind = self.vocab[self.dataset_params.unk_word]
self.pad_ind = self.vocab[self.dataset_params.pad_word]
# loading tags (we require this to map tags to their indices)
tags_path = os.path.join(data_dir, 'tags.txt')
self.tag_map = {}
with open(tags_path) as f:
for i, t in enumerate(f.read().splitlines()):
self.tag_map[t] = i
# adding dataset parameters to param (e.g. vocab size, )
params.update(json_path)
def train_CRN_Net(args):
cfg = Params(os.path.join("../config", args.config))
# set up params
cfg.ctx = [int(i) for i in args.gpu.split(',')]
if len(cfg.ctx) > 1:
Exception('Only for 1-GPU mode')
cfg_attr = vars(cfg)
cfg_attr.update(vars(args))
# set up data loader
trainIter = dataIter(cfg)
# set up model
if cfg.backbone == 'CRN_Res101':
model = CRN(mtype=101, num_classes=1)
if cfg.backbone == 'CRN_Res50':
model = CRN(mtype=50, num_classes=1)
if args.resume:
mdl_dir = args.model_dir
pre_pfx = args.pretrained_prefix
pre_epc = args.pretrained_epoch
net_pfx = cfg.network
saved_state_dict = torch.load(
os.path.join(mdl_dir, pre_pfx, net_pfx + '_' + pre_epc + '.pth'))
model.load_state_dict(saved_state_dict)
if cfg.use_global_stats == True:
model.eval() #
if len(cfg.ctx) > 0:
model.cuda(cfg.ctx[0])
# set up optimizer
if cfg.optimizer == 'SGD':
optimizer = optim.SGD(model.parameters(),
lr=cfg.learning_rate,
momentum=cfg.momentum,
weight_decay=cfg.wd) #
elif cfg.optimizer == 'Adam':
optimizer = optim.Adam(model.parameters(),
lr=cfg.learning_rate,
weight_decay=cfg.wd)
else:
Exception('SGD or Adam')
optimizer.zero_grad()
# set up model path
model_path = os.path.join(args.model_dir, cfg.prefix)
if not os.path.isdir(model_path):
os.mkdir(model_path)
model_full_path = os.path.join(model_path,
datetime.now().strftime('%Y_%m_%d_%H_%M'))
if not os.path.isdir(model_full_path):
os.mkdir(model_full_path)
# set up log
util.save_log(cfg.prefix, model_full_path)
logging.info(
'---------------------------TIME-------------------------------')
logging.info('-------------------{}------------------------'.format(
datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
for k, v in sorted(cfg_attr.items(), key=lambda x: x[0]):
logging.info("%s : %s", k, v)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# training phase
for epoch in range(cfg.begin_epoch, cfg.end_epoch):
trainIter.reset()
totalLoss = 0.0
tic = time.time()
for iter in tqdm(range(trainIter.iter_cnt)):
img, msk_16, msk_32, gt0, gt1, gt2, gt3, gt4, gt5 = trainIter.next(
)
out = model([img, msk_32])
loss0 = Loss_calc(out[0], gt0)
loss1 = Loss_calc(out[1], gt1)
loss2 = Loss_calc(out[2], gt2)
loss3 = Loss_calc(out[3], gt3)
loss4 = Loss_calc(out[4], gt4)
loss5 = Loss_calc(out[5], gt5)
loss = loss0 + loss1 + loss2 + loss3 + loss4 + loss5
loss.backward()
if iter % cfg.updateIter == 0:
optimizer.step()
optimizer.zero_grad()
totalLoss += loss.data.cpu().numpy() / trainIter.iter_cnt
logger.info('Epoch[%d] Train-Loss=%.5f', epoch, totalLoss)
toc = time.time()
logger.info('Epoch[%d] Time cost=%.3f', epoch, (toc - tic))
if epoch % cfg.frequence == 0:
print 'taking snapshot: ' + os.path.join(cfg.network + '_' +
str(epoch) + '.pth')
torch.save(
model.cpu().state_dict(),
os.path.join(model_full_path,
cfg.network + '-' + str(epoch) + '.pth'))
model.cuda(cfg.ctx[0])
def main():
start_time = time.strftime("%d%m%y_%H%M%S")
parser = argparse.ArgumentParser()
parser.add_argument("model_name",
type=str,
help="Pass name of model as defined in hparams.yaml.")
args = parser.parse_args()
# Parse our YAML file which has our model parameters.
params = Params("hparams.yaml", args.model_name)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = params.gpu_vis_dev
# Check if a GPU is available and use it if so.
use_gpu = torch.cuda.is_available()
device = torch.device("cuda" if use_gpu else "cpu")
# Load model that has been chosen via the command line arguments.
model_module = __import__('.'.join(['models', params.model_name]),
fromlist=['object'])
model = model_module.net(**params.net_args)
# Send the model to the chosen device.
# To use multiple GPUs
# model = nn.DataParallel(model)
model.to(device)
# Grap your training and validation functions for your network.
train = model_module.train
val = model_module.val
optimizer = optim.Adam(model.parameters(), lr=params.lr)
# This is useful if you have multiple custom datasets defined.
Dataset = getattr(Datasets, params.dataset_class)
augments_train = getattr(model_augments, params.augments_train)()
augments_val = getattr(model_augments, params.augments_val)()
train_data = Dataset(params.data_dir + "/train",
augmentations=augments_train)
val_data = Dataset(params.data_dir + "/val", augmentations=augments_val)
train_loader = DataLoader(train_data,
batch_size=params.batch_size,
shuffle=True)
val_loader = DataLoader(val_data,
batch_size=params.batch_size,
shuffle=False)
os.makedirs(params.log_dir, exist_ok=True)
os.makedirs(params.checkpoint_dir, exist_ok=True)
os.makedirs(params.data_dir, exist_ok=True)
os.makedirs("figs", exist_ok=True)
val_roc_aucs = []
val_losses = []
train_losses = []
train_roc_aucs = []
for epoch in range(1, params.num_epochs + 1):
print("Epoch: {}".format(epoch))
# Call training function.
train(model, device, train_loader, optimizer)
# Evaluate on both the training and validation set.
train_loss, train_roc_auc = val(model, device, train_loader)
val_loss, val_roc_auc = val(model, device, val_loader)
# Collect some data for logging purposes.
train_losses.append(float(train_loss))
train_roc_aucs.append(train_roc_auc)
val_losses.append(float(val_loss))
val_roc_aucs.append(val_roc_auc)
print(
'\n\ttrain Loss: {:.6f}\ttrain roc_auc: {:.6f} \n\tval Loss: {:.6f}\tval roc_auc: {:.6f}'
.format(train_loss, train_roc_auc, val_loss, val_roc_auc))
# Here is a simply plot for monitoring training.
# Clear plot each epoch
fig = plot_training(train_losses, train_roc_aucs, val_losses,
val_roc_aucs)
fig.savefig(
os.path.join("figs", "{}_training_vis".format(args.model_name)))
# Save model every few epochs (or even more often if you have the disk space).
if epoch % 5 == 0:
torch.save(
model.state_dict(),
os.path.join(
params.checkpoint_dir,
"checkpoint_{}_epoch_{}".format(args.model_name, epoch)))
# Some log information to help you keep track of your model information.
logs = {
"model": args.model_name,
"net_args": params.net_args,
"train_losses": train_losses,
"train_roc_aucs": train_roc_aucs,
"val_losses": val_losses,
"val_roc_aucs": val_roc_aucs,
"best_val_epoch": int(np.argmax(val_roc_aucs) + 1),
"model": args.model_name,
"lr": params.lr,
"batch_size": params.batch_size,
"augments_train": str(augments_train),
"augments_val": str(augments_val)
}
with open(
os.path.join(params.log_dir,
"{}_{}.json".format(args.model_name, start_time)),
'w') as f:
json.dump(logs, f)
save_model(model, params, performance_str)
return performance_dict
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='running experiments on multimodal datasets.')
parser.add_argument('-config',
action='store',
dest='config_file',
help='please enter configuration file.',
default='config/run.ini')
args = parser.parse_args()
params = Params()
params.parse_config(args.config_file)
params.config_file = args.config_file
mode = 'run'
if 'mode' in params.__dict__:
mode = params.mode
set_seed(params)
params.device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
if mode == 'run':
results = []
reader = setup(params)
reader.read(params)
print(params.output_dim_emo)
def train_Tube_Net(args):
cfg = Params(os.path.join("../config",args.config))
# set up params
cfg.ctx = [int(i) for i in args.gpu.split(',')]
if len(cfg.ctx)>1:
Exception('Only for 1-GPU mode')
cfg_attr = vars(cfg)
cfg_attr.update(vars(args))
# set up model path
model_path = os.path.join(args.model_dir, cfg.prefix)
if not os.path.isdir(model_path):
os.mkdir(model_path)
model_full_path = os.path.join(
model_path, datetime.now().strftime('%Y_%m_%d_%H_%M'))
if not os.path.isdir(model_full_path):
os.mkdir(model_full_path)
# set up log
util.save_log(cfg.prefix, model_full_path)
logging.info(
'---------------------------TIME-------------------------------')
logging.info('-------------------{}------------------------'.format(
datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
for k, v in sorted(cfg_attr.items(), key=lambda x: x[0]):
logging.info("%s : %s", k, v)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
name_list, f1_img, f1_gt, img_list, label_list = read_vos_test_list(cfg)
mIoU = 0.0
MAE = 0.0
seq_num = len(name_list)
for seq_i in range(seq_num):
seq = name_list[seq_i]
f1_i = f1_img[seq_i]
f1_g = f1_gt[seq_i]
imgs = img_list[seq_i]
labels = label_list[seq_i]
# set up model
if cfg.backbone == 'CRN_Res101':
model = CRN(mtype=101,num_classes=1)
if cfg.backbone == 'CRN_Res50':
model = CRN(mtype=50,num_classes=1)
if args.resume==1:
print('load model:'+args.trained_path)
logging.info('load model:'+args.trained_path)
saved_state_dict = torch.load(args.trained_path)
model.load_state_dict(saved_state_dict)
if cfg.use_global_stats == True:
model.eval() # use_global_stats = True
if len(cfg.ctx)>0:
model.cuda(cfg.ctx[0])
# set up optimizer
if cfg.optimizer == 'SGD':
optimizer = optim.SGD(model.parameters(),lr = cfg.learning_rate,
momentum = cfg.momentum, weight_decay = cfg.wd)#
elif cfg.optimizer == 'Adam':
optimizer = optim.Adam(model.parameters(),lr = cfg.learning_rate, weight_decay = cfg.wd)
else:
Exception('SGD or Adam')
optimizer.zero_grad()
totalLoss = 0.0
tic = time.time()
logger.info('Finetuning on the set- %s', seq)
for epoch in tqdm(range(cfg.finetune_epoch)):
img,msk_16,msk_32,gt0,gt1,gt2,gt3,gt4,gt5= get_training_batch(cfg,f1_i,f1_g)
out = model([img,msk_32])
loss0 = Loss_calc(out[0],gt0)
loss1 = Loss_calc(out[1],gt1)
loss2 = Loss_calc(out[2],gt2)
loss3 = Loss_calc(out[3],gt3)
loss4 = Loss_calc(out[4],gt4)
loss5 = Loss_calc(out[5],gt5)
loss = loss0 + loss1 + loss2 + loss3 + loss4 + loss5
loss.backward()
optimizer.step()
optimizer.zero_grad()
totalLoss += loss.data.cpu().numpy()/cfg.finetune_epoch
model.eval()
torch.save(model.cpu().state_dict(),os.path.join(model_full_path,seq+'_iter'+str(cfg.finetune_epoch)+'.pth'))
model.cuda(cfg.ctx[0])
toc = time.time()
logger.info('Train-Loss=%.5f, Time cost=%.3f', totalLoss,(toc - tic))
iouu = 0.0
mae = 0.0
img_ = imgs[0]
label_ = labels[0]
img_test,lbl_test,mask_test=get_testing_batch(cfg,img_,label_)
mask__ = lbl_test[0,0].cpu().data.numpy()
for test_ in range(len(imgs)):
model.eval()
torch.cuda.empty_cache()
img_ = imgs[test_]
label_ = labels[test_]
img_test,lbl_test,mask_test=get_testing_batch(cfg,img_,label_)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(8,8))
mask__ = cv2.dilate(mask__,kernel)
mask_temp = mask__>0
msk_atn0 = cv2.resize(mask_temp.astype(np.float),(256,256) , interpolation = cv2.INTER_NEAREST)
msk_atn0 = Variable(torch.from_numpy(msk_atn0).float().view(1,1,256,256)).cuda(cfg.ctx[0])
msk_atn1 = cv2.resize(mask_temp.astype(np.float),(128,128) , interpolation = cv2.INTER_NEAREST)
msk_atn1 = Variable(torch.from_numpy(msk_atn1).float().view(1,1,128,128)).cuda(cfg.ctx[0])
msk_atn2 = cv2.resize(mask_temp.astype(np.float),(64,64) , interpolation = cv2.INTER_NEAREST)
msk_atn2 = Variable(torch.from_numpy(msk_atn2).float().view(1,1,64,64)).cuda(cfg.ctx[0])
msk_atn3 = cv2.resize(mask_temp.astype(np.float),(32,32) , interpolation = cv2.INTER_NEAREST)
msk_atn3 = Variable(torch.from_numpy(msk_atn3).float().view(1,1,32,32)).cuda(cfg.ctx[0])
msk_atn4 = cv2.resize(mask_temp.astype(np.float),(16,16) , interpolation = cv2.INTER_NEAREST)
msk_atn4 = Variable(torch.from_numpy(msk_atn4).float().view(1,1,16,16)).cuda(cfg.ctx[0])
mask_ = cv2.resize(mask__.astype(np.float),(16,16) )
mask_t = Variable(torch.from_numpy(mask_).float().view(1,16,16))
out = model([img_test,mask_t.cuda(cfg.ctx[0])])
mask_out = (out[0][0,0].cpu().data.numpy()>0.5).astype(np.float)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(64, 64))
mask__ = cv2.dilate(mask__,kernel)
mask__ = mask_out*mask__
lbl_test = (lbl_test).cpu().data.numpy()
#cv2.imshow("mask__",mask__)
#cv2.waitKey (50)
iouu += compute_iou_for_binary_segmentation(mask__>0.5,lbl_test[:,:]>0.5)
mae += (np.abs(mask__-lbl_test[:,:])).sum()
mIoU += iouu/len(imgs)
MAE += mae/len(imgs)/(cfg.frame_num*cfg.img_size/8*cfg.img_size/8)
logger.info('Testing: mIoU-%.5f, MAE-%.5f', iouu/len(imgs), mae/len(imgs)/(cfg.frame_num*cfg.img_size/8*cfg.img_size/8))
logger.info('---------------------------------')
logger.info('####################################')
logger.info('Total Testing: mIoU-%.5f, MAE-%.5f', mIoU/seq_num, MAE/seq_num)
logger.info('####################################')
# results["mean_iou"] = IOULoss().forward(groundtruth, mesh_silhouettes).detach().cpu().numpy().tolist()
# results["mean_dice"] = DiceCoeffLoss().forward(groundtruth, mesh_silhouettes)
manager.set_pred_results(results)
manager.close()
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
args = get_args()
args_dict = vars(args)
params = Params()
params.config_file = args_dict['config_file']
params.__post_init__()
params._set_with_dict(args_dict)
params.ransac_iou_threshold = args_dict['ransac_iou_threshold']
# Set the device
dev_num = params.gpu_num
os.environ["CUDA_VISIBLE_DEVICES"] = dev_num
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
device = torch.device(f"cuda" if torch.cuda.is_available() else "cpu")
logging.info(f"Using {device} as computation device")
if device == f"cuda":
torch.cuda.set_device()
logging.info(f"Using {device} as computation device")
params.device = device
{
"model": model.module.state_dict(),
"unet_optimizer": unet_optimizer.state_dict(),
"pose_optimizer": pose_optimizer.state_dict(),
},
model_dir,
)
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
args = get_args()
args_dict = vars(args)
params = Params()
params.config_file = args_dict['config_file']
params.__post_init__()
params.gpu_num = args_dict['gpu_num']
# Set the device
dev_num = params.gpu_num
os.environ["CUDA_VISIBLE_DEVICES"] = dev_num
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
device = torch.device(f"cuda" if torch.cuda.is_available() else "cpu")
logging.info(f"Using {device} as computation device")
if device == f"cuda":
torch.cuda.set_device()
logging.info(f"Using {device} as computation device")
params.device = device
def run(params):
train(params)
print('loading the pretraining model...')
model = torch.load('dummy_files/best_model.pt')
generate_visual_rep(model, params)
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='running experiments on multimodal datasets.')
parser.add_argument('-config',
action='store',
dest='config_file',
help='please enter configuration file.',
default='config/pretrain_visual.ini')
args = parser.parse_args()
params = Params()
params.parse_config(args.config_file)
params.config_file = args.config_file
mode = 'run'
if 'mode' in params.__dict__:
mode = params.mode
set_seed(params)
params.device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
if mode == 'extract_raw_feature':
extract_raw_features(params)
elif mode == 'run':
run(params)
import os
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.losses import categorical_crossentropy
from tensorflow.keras.optimizers import Adam, SGD
from tensorflow.keras.models import load_model
from models.networks import get_models_I3D_LSTM
from tensorflow.keras.callbacks import ModelCheckpoint
from utils.pre_process import pre_process_sequence
from utils.params import Params
from utils.videoto3D import Videoto3D
from utils.sequence import UCF101_Sequence
model = get_models_I3D_LSTM()
prs = Params()
X_train, X_test, y_train, y_test = pre_process_sequence()
loader = Videoto3D(n_frames=40, mode='rgb')
sequenceTrain = UCF101_Sequence(X_train,
y_train,
loader=loader,
folder_image=prs.path_img,
batch_size=prs.batch_size,
image_size=prs.image_size)
sequenceTest = UCF101_Sequence(X_test,
y_test,
loader=loader,
folder_image=prs.path_img,
def from_params(cls: Type[T], params: Params, **extras) -> T:
"""
This is the automatic implementation of `from_params`. Any class that subclasses `FromParams`
(or `Registrable`, which itself subclasses `FromParams`) gets this implementation for free.
If you want your class to be instantiated from params in the "obvious" way -- pop off parameters
and hand them to your constructor with the same names -- this provides that functionality.
If you need more complex logic in your from `from_params` method, you'll have to implement
your own method that overrides this one.
"""
# pylint: disable=protected-access
from stog.utils.registrable import Registrable # import here to avoid circular imports
logger.info(
f"instantiating class {cls} from params {getattr(params, 'params', params)} "
f"and extras {extras}")
if params is None:
return None
registered_subclasses = Registrable._registry.get(cls)
if registered_subclasses is not None:
# We know ``cls`` inherits from Registrable, so we'll use a cast to make mypy happy.
# We have to use a disable to make pylint happy.
# pylint: disable=no-member
as_registrable = cast(Type[Registrable], cls)
default_to_first_choice = as_registrable.default_implementation is not None
choice = params.pop_choice(
"type",
choices=as_registrable.list_available(),
default_to_first_choice=default_to_first_choice)
subclass = registered_subclasses[choice]
# We want to call subclass.from_params. It's possible that it's just the "free"
# implementation here, in which case it accepts `**extras` and we are not able
# to make any assumptions about what extra parameters it needs.
#
# It's also possible that it has a custom `from_params` method. In that case it
# won't accept any **extra parameters and we'll need to filter them out.
if not takes_arg(subclass.from_params, 'extras'):
# Necessarily subclass.from_params is a custom implementation, so we need to
# pass it only the args it's expecting.
extras = {
k: v
for k, v in extras.items()
if takes_arg(subclass.from_params, k)
}
return subclass.from_params(params=params, **extras)
else:
# This is not a base class, so convert our params and extras into a dict of kwargs.
if cls.__init__ == object.__init__:
# This class does not have an explicit constructor, so don't give it any kwargs.
# Without this logic, create_kwargs will look at object.__init__ and see that
# it takes *args and **kwargs and look for those.
kwargs: Dict[str, Any] = {}
else:
# This class has a constructor, so create kwargs for it.
kwargs = create_kwargs(cls, params, **extras)
return cls(**kwargs) # type: ignore
params.align_function)
output_dir = os.path.join(params.datasets_dir, align_output_dir)
dataset.deploy(output_dir, deploy_files)
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='running experiments on multimodal datasets.')
parser.add_argument('-config',
action='store',
dest='config_file',
help='please enter configuration file.',
default='config/extract.ini')
args = parser.parse_args()
params = Params()
params.parse_config(args.config_file)
params.config_file = args.config_file
mode = 'extract'
if 'mode' in params.__dict__:
mode = params.mode
if mode == 'download':
download(params)
elif mode == 'align':
align(params)
elif mode == 'extract':
reader = dataset.setup(params)
reader.read_data_from_sdk()
def main(dataset_name,
experiment_name,
train_model=False,
evaluate_model=False,
compute_dset_mean_std=False,
compute_dset_gt_bounds=False):
"""
Args:
dataset_name: str - name of the dataset -> from constants.py
experiment_name: str - name of the experiment folder
train_model: bool - begin trainig if true
evaluate_model: bool - run validation if true
compute_dset_mean_std: bool - compute mean and std of the dataset
compute_dset_gt_bounds: bool - compute coordinates of an encompassing box of the labelled area
of the training set
"""
config = Params(constants.config_path.format(dataset_name,
experiment_name))
params = Params(constants.params_path.format(dataset_name,
experiment_name))
stats = Params(constants.stats_path.format(dataset_name, experiment_name))
validate_params(params)
prints.show_training_info(params)
training_dataloader, validation_dataloader = training_setup.prepare_dataloaders(
params, config)
prints.print_dataset_stats(training_dataloader, validation_dataloader)
model = training_setup.model_setup(params, config)
optimizer = training_setup.optimizer_setup(model, params)
start_epoch = 0
if hasattr(params, "load_type"):
start_epoch = training_setup.load_model(model, optimizer, params,
dataset_name, experiment_name)
else:
if amp_available and general_config.use_amp:
model, optimizer = amp.initialize(
model, optimizer, opt_level=general_config.amp_opt_level)
prints.print_trained_parameters_count(model, optimizer)
experiment_info = prints.create_tensorboard_name(dataset_name,
experiment_name, params)
if config.model_id in constants.segmentor_ids:
model_trainer = train.Segmentation_Trainer(
model=model,
training_dataloader=training_dataloader,
validation_dataloader=validation_dataloader,
optimizer=optimizer,
params=params,
config=config,
stats=stats,
start_epoch=start_epoch,
dataset_name=dataset_name,
experiment_info=experiment_info,
experiment_name=experiment_name)
elif config.model_id in constants.detectors:
model_trainer = train.Detector_Trainer(
model=model,
training_dataloader=training_dataloader,
validation_dataloader=validation_dataloader,
optimizer=optimizer,
params=params,
config=config,
stats=stats,
start_epoch=start_epoch,
dataset_name=dataset_name,
experiment_info=experiment_info,
experiment_name=experiment_name)
if train_model:
model_trainer.train()
if evaluate_model:
model_trainer.evaluate(start_epoch, no_saving=True)
if compute_dset_mean_std:
print("Computing dataset mean and std!")
images = training_dataloader.dataset.get_images()
mean, std = data_normalization.per_dataset_norm(images)
print("Dataset mean and standard deviation: ", mean, std)
if compute_dset_gt_bounds:
roi_crop.get_dataset_gt_bounds(dataset_name, params, config)
def __init__(self, device, params=Params(), template_mesh=None):
super().__init__()
self.device = device
self.params = params
self.mesh_scale = params.mesh_sphere_scale
self.ico_level = params.mesh_sphere_level
self.is_real_data = params.is_real_data
self.init_pose_R = None
self.init_pose_t = None
# Create a source mesh
if not template_mesh:
template_mesh = ico_sphere(params.mesh_sphere_level, device)
template_mesh.scale_verts_(params.mesh_sphere_scale)
# for EVIMO data, we need to apply a delta Transform to adjust the pose in the EVIMO coordinate system
# to PyTorch3D system
# Since we don't know the initial transform, we optimize the initial pose as a parameter while render the mesh
# initialize the delta Transform
if params.is_real_data:
init_trans = Transform3d(device=device)
R_init = init_trans.get_matrix()[:, :3, :3]
qua_init = matrix_to_quaternion(R_init)
random_noise = (torch.randn(qua_init.shape) /
params.mesh_pose_init_noise_var).to(self.device)
qua_init += random_noise
t_init = init_trans.get_matrix()[:, 3:, :3]
random_noise_t = (torch.randn(t_init.shape) /
params.mesh_pose_init_noise_var).to(self.device)
t_init += random_noise_t
self.register_parameter('init_camera_R',
nn.Parameter(qua_init).to(self.device))
self.register_parameter('init_camera_t',
nn.Parameter(t_init).to(self.device))
verts, faces = template_mesh.get_mesh_verts_faces(0)
# Initialize each vert to have no tetxture
verts_rgb = torch.ones_like(verts)[None]
textures = TexturesVertex(verts_rgb.to(self.device))
self.template_mesh = Meshes(
verts=[verts.to(self.device)],
faces=[faces.to(self.device)],
textures=textures,
)
self.register_buffer("vertices", self.template_mesh.verts_padded())
self.register_buffer("faces", self.template_mesh.faces_padded())
self.register_buffer("textures", textures.verts_features_padded())
deform_verts = torch.zeros_like(self.template_mesh.verts_packed(),
device=device,
requires_grad=True)
# Create an optimizable parameter for the mesh
self.register_parameter("deform_verts",
nn.Parameter(deform_verts).to(self.device))
# Create optimizer
self.optimizer = self.params.mesh_optimizer(
self.parameters(),
lr=self.params.mesh_learning_rate,
betas=self.params.mesh_betas)
self.losses = {"iou": [], "laplacian": [], "flatten": []}
# Create a silhouette_renderer
self.renderer = silhouette_renderer(self.params.img_size, device)
def print_result_from_dir(dir_path):
params = Params()
params.parse_config(os.path.join(dir_path, 'config.ini'))
reader = open(os.path.join(dir_path,'eval'),'r')
s = reader.readline().split()
print('dataset: {}, network_type: {}, acc: {}, f1:{}'.format(params.dataset_name,params.network_type,s[2],s[5]))
def create_kwargs(cls: Type[T], params: Params, **extras) -> Dict[str, Any]:
"""
Given some class, a `Params` object, and potentially other keyword arguments,
create a dict of keyword args suitable for passing to the class's constructor.
The function does this by finding the class's constructor, matching the constructor
arguments to entries in the `params` object, and instantiating values for the parameters
using the type annotation and possibly a from_params method.
Any values that are provided in the `extras` will just be used as is.
For instance, you might provide an existing `Vocabulary` this way.
"""
# Get the signature of the constructor.
signature = inspect.signature(cls.__init__)
kwargs: Dict[str, Any] = {}
# Iterate over all the constructor parameters and their annotations.
for name, param in signature.parameters.items():
# Skip "self". You're not *required* to call the first parameter "self",
# so in theory this logic is fragile, but if you don't call the self parameter
# "self" you kind of deserve what happens.
if name == "self":
continue
# If the annotation is a compound type like typing.Dict[str, int],
# it will have an __origin__ field indicating `typing.Dict`
# and an __args__ field indicating `(str, int)`. We capture both.
annotation = remove_optional(param.annotation)
origin = getattr(annotation, '__origin__', None)
args = getattr(annotation, '__args__', [])
# The parameter is optional if its default value is not the "no default" sentinel.
default = param.default
optional = default != _NO_DEFAULT
# Some constructors expect extra non-parameter items, e.g. vocab: Vocabulary.
# We check the provided `extras` for these and just use them if they exist.
if name in extras:
kwargs[name] = extras[name]
# The next case is when the parameter type is itself constructible from_params.
elif hasattr(annotation, 'from_params'):
if name in params:
# Our params have an entry for this, so we use that.
subparams = params.pop(name)
if takes_arg(annotation.from_params, 'extras'):
# If annotation.params accepts **extras, we need to pass them all along.
# For example, `BasicTextFieldEmbedder.from_params` requires a Vocabulary
# object, but `TextFieldEmbedder.from_params` does not.
subextras = extras
else:
# Otherwise, only supply the ones that are actual args; any additional ones
# will cause a TypeError.
subextras = {
k: v
for k, v in extras.items()
if takes_arg(annotation.from_params, k)
}
# In some cases we allow a string instead of a param dict, so
# we need to handle that case separately.
if isinstance(subparams, str):
kwargs[name] = annotation.by_name(subparams)()
else:
kwargs[name] = annotation.from_params(params=subparams,
**subextras)
elif not optional:
# Not optional and not supplied, that's an error!
raise ConfigurationError(
f"expected key {name} for {cls.__name__}")
else:
kwargs[name] = default
# If the parameter type is a Python primitive, just pop it off
# using the correct casting pop_xyz operation.
elif annotation == str:
kwargs[name] = (params.pop(name, default)
if optional else params.pop(name))
elif annotation == int:
kwargs[name] = (params.pop_int(name, default)
if optional else params.pop_int(name))
elif annotation == bool:
kwargs[name] = (params.pop_bool(name, default)
if optional else params.pop_bool(name))
elif annotation == float:
kwargs[name] = (params.pop_float(name, default)
if optional else params.pop_float(name))
# This is special logic for handling types like Dict[str, TokenIndexer], which it creates by
# instantiating each value from_params and returning the resulting dict.
elif origin in (Dict, dict) and len(args) == 2 and hasattr(
args[-1], 'from_params'):
value_cls = annotation.__args__[-1]
value_dict = {}
for key, value_params in params.pop(name, Params({})).items():
value_dict[key] = value_cls.from_params(params=value_params,
**extras)
kwargs[name] = value_dict
else:
# Pass it on as is and hope for the best. ¯\_(ツ)_/¯
if optional:
kwargs[name] = params.pop(name, default)
else:
kwargs[name] = params.pop(name)
params.assert_empty(cls.__name__)
return kwargs
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"val_json",
type=str,
help=
"Directory of validation json file which indictates the best epoch.")
parser.add_argument("eval_iter",
type=int,
default=5,
help="Number of times to train and evaluate model")
args = parser.parse_args()
with open(args.val_json) as f:
model_params = json.load(f)
params = Params("hparams.yaml", model_params["model"])
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = params.gpu_vis_dev
use_gpu = torch.cuda.is_available()
device = torch.device("cuda" if use_gpu else "cpu")
log_dir = os.path.join(params.log_dir, "eval_logs")
if not os.path.exists(log_dir): os.makedirs(log_dir)
model_module = __import__('.'.join(['models', params.model_name]),
fromlist=['object'])
Dataset = getattr(Datasets, params.dataset_class)
roc_auc_scores = []
for iter_i in range(args.eval_iter):
print("Training model for iteration {}...".format(iter_i))
model = model_module.net().to(device)
train = model_module.train
test = model_module.test
optimizer = optim.Adam(model.parameters(), lr=model_params['lr'])
train_data_dir = os.path.join(params.data_dir, "train")
Dataset = getattr(Datasets, params.dataset_class)
augments_train = getattr(model_augments, params.augments_train)()
train_data = Dataset(params.data_dir + "/train",
augmentations=augments_train)
train_loader = DataLoader(train_data,
batch_size=params.batch_size,
shuffle=True)
if not os.path.exists(params.checkpoint_dir):
os.makedirs(params.checkpoint_dir)
for epoch in range(1, model_params["best_val_epoch"] + 1):
train(model, device, train_loader, optimizer)
# Just save the last epoch of each iteration.
torch.save(
model.state_dict(),
os.path.join(
params.checkpoint_dir, "checkpoint_{}_epoch_{}_iter_{}".format(
model_params["model"], epoch, iter_i)))
print("Evaluating model for iteration {}...".format(iter_i))
test_data_dir = os.path.join(params.data_dir, "test.csv")
augments_val = getattr(model_augments, params.augments_val)()
test_data = Dataset(params.data_dir + "/test",
augmentations=augments_val)
test_loader = DataLoader(test_data,
batch_size=params.batch_size,
shuffle=False)
roc_auc_score = test(model, device, test_loader)
print("ROC AUC for iteration {}\t {}".format(iter_i, roc_auc_score))
roc_auc_scores.append(float(roc_auc_score))
logs = {
"model": model_params["model"],
"num_epochs": model_params["best_val_epoch"],
"lr": model_params['lr'],
"batch_size": model_params["batch_size"],
"eval_iterations": args.eval_iter,
"roc_auc_scores": roc_auc_scores,
"mean_roc_auc": float(np.mean(roc_auc_scores)),
"var_roc_auc": float(np.var(roc_auc_scores)),
}
with open(
os.path.join(
log_dir, "{}_{}.json".format(model_params["model"],
args.eval_iter)), 'w') as f:
json.dump(logs, f)
