# Calibrate samplers
training_sampler.calibration(training_loader, verbose=True)
test_sampler.calibration(test_loader, verbose=True)
# Optional debug functions
# debug_timing(training_dataset, training_loader)
# debug_timing(test_dataset, test_loader)
# debug_upsampling(training_dataset, training_loader)
print('\nModel Preparation')
print('*****************')
# Define network model
t1 = time.time()
net = KPFCNN(config, training_dataset.label_values,
training_dataset.ignored_labels)
debug = False
if debug:
print('\n*************************************\n')
print(net)
print('\n*************************************\n')
for param in net.parameters():
if param.requires_grad:
print(param.shape)
print('\n*************************************\n')
print("Model size %i" %
sum(param.numel()
for param in net.parameters() if param.requires_grad))
print('\n*************************************\n')
# model initialization
config.architecture = [
'simple',
'resnetb',
]
for i in range(config.num_layers-1):
config.architecture.append('resnetb_strided')
config.architecture.append('resnetb')
config.architecture.append('resnetb')
for i in range(config.num_layers-2):
config.architecture.append('nearest_upsample')
config.architecture.append('unary')
config.architecture.append('nearest_upsample')
config.architecture.append('last_unary')
config.model = KPFCNN(config)
# create optimizer
if config.optimizer == 'SGD':
config.optimizer = optim.SGD(
config.model.parameters(),
lr=config.lr,
momentum=config.momentum,
weight_decay=config.weight_decay,
)
elif config.optimizer == 'ADAM':
config.optimizer = optim.Adam(
config.model.parameters(),
lr=config.lr,
betas=(0.9, 0.999),
# config.architecture.append('unary')
# config.architecture.append('nearest_upsample')
# config.architecture.append('last_unary')
#
# # dynamically load the model from snapshot
# module_file_path = f'snapshot/{chosen_snap}/model.py'
# module_name = 'model'
# module_spec = importlib.util.spec_from_file_location(module_name, module_file_path)
# module = importlib.util.module_from_spec(module_spec)
# module_spec.loader.exec_module(module)
# model = module.KPFCNN(config)
# if test on datasets with different scale
# config.first_subsampling_dl = [new voxel size for first layer]
model = KPFCNN(config)
model.load_state_dict(
torch.load(
f'./data/D3Feat/snapshot/{args.chosen_snapshot}/models/model_best_acc.pth'
)['state_dict'])
print(
f"Load weight from snapshot/{args.chosen_snapshot}/models/model_best_acc.pth"
)
model.eval()
save_path = f'geometric_registration/{args.chosen_snapshot}'
if not os.path.exists(save_path):
os.mkdir(save_path)
if args.generate_features:
collate_fn=collate_fn,
num_workers=config.input_threads,
pin_memory=True)
# Calibrate samplers
test_sampler.calibration(test_loader, verbose=True)
print('\nModel Preparation')
print('*****************')
# Define network model
t1 = time.time()
if config.dataset_task == 'classification':
net = KPCNN(config)
elif config.dataset_task in ['cloud_segmentation', 'slam_segmentation']:
net = KPFCNN(config, test_dataset.label_values, test_dataset.ignored_labels)
else:
raise ValueError('Unsupported dataset_task for deformation visu: ' + config.dataset_task)
# Define a visualizer class
visualizer = ModelVisualizer(net, config, chkp_path=chosen_chkp, on_gpu=False)
print('Done in {:.1f}s\n'.format(time.time() - t1))
print('\nStart visualization')
print('*******************')
# Training
visualizer.show_deformable_kernels(net, test_loader, config, deform_idx)
# Calibrate samplers
training_sampler.calibration(training_loader, verbose=True)
test_sampler.calibration(test_loader, verbose=True)
# Optional debug functions
# debug_timing(training_dataset, training_loader)
# debug_timing(test_dataset, test_loader)
# debug_upsampling(training_dataset, training_loader)
print('\nModel Preparation')
print('*****************')
# Define network model
t1 = time.time()
net = KPFCNN(config, training_dataset.label_values, training_dataset.ignored_labels)
debug = False
if debug:
print('\n*************************************\n')
print(net)
print('\n*************************************\n')
for param in net.parameters():
if param.requires_grad:
print(param.shape)
print('\n*************************************\n')
print("Model size %i" % sum(param.numel() for param in net.parameters() if param.requires_grad))
print('\n*************************************\n')
# Define a trainer class
trainer = ModelTrainer(net, config, chkp_path=chosen_chkp)
# Calibrate samplers
training_sampler.calibration(training_loader, verbose=True)
test_sampler.calibration(test_loader, verbose=True)
# Optional debug functions
# debug_timing(training_dataset, training_loader)
# debug_timing(test_dataset, test_loader)
# debug_upsampling(training_dataset, training_loader)
print('\nModel Preparation')
print('*****************')
# Define network model
t1 = time.time()
net = KPFCNN(config, training_dataset.label_values,
training_dataset.ignored_labels)
net = nn.DataParallel(net.cuda())
# net = net.cuda()
debug = False
if debug:
print('\n*************************************\n')
print(net)
print('\n*************************************\n')
for param in net.parameters():
if param.requires_grad:
print(param.shape)
print('\n*************************************\n')
print("Model size %i" %
sum(param.numel()
for param in net.parameters() if param.requires_grad))
def test_model(chosen_log):
###############################
# Choose the model to visualize
###############################
# Here you can choose which model you want to test with the variable test_model. Here are the possible values :
#
# > 'last_XXX': Automatically retrieve the last trained model on dataset XXX
# > '(old_)results/Log_YYYY-MM-DD_HH-MM-SS': Directly provide the path of a trained model
# Choose the index of the checkpoint to load OR None if you want to load the current checkpoint
chkp_idx = None
# Choose to test on validation or test split
on_val = False
# Deal with 'last_XXXXXX' choices
chosen_log = model_choice(chosen_log)
############################
# Initialize the environment
############################
# Set which gpu is going to be used
GPU_ID = '0'
# Set GPU visible device
os.environ['CUDA_VISIBLE_DEVICES'] = GPU_ID
###############
# Previous chkp
###############
# Find all checkpoints in the chosen training folder
chkp_path = os.path.join(chosen_log, 'checkpoints')
chkps = [f for f in os.listdir(chkp_path) if f[:4] == 'chkp']
# Find which snapshot to restore
if chkp_idx is None:
chosen_chkp = 'current_chkp.tar'
else:
chosen_chkp = np.sort(chkps)[chkp_idx]
chosen_chkp = os.path.join(chosen_log, 'checkpoints', chosen_chkp)
# Initialize configuration class
config = Config()
config.load(chosen_log)
##################################
# Change model parameters for test
##################################
# Change parameters for the test here. For example, you can stop augmenting the input data.
#config.augment_noise = 0.0001
#config.augment_symmetries = False
# config.batch_num = 1
#config.in_radius = 4
config.validation_size = 200
config.input_threads = 0
config.saving_path = "./test_results"
##############
# Prepare Data
##############
print()
print('Data Preparation')
print('****************')
if on_val:
set = 'validation'
else:
set = 'test'
# Initiate dataset
if config.dataset.startswith('ModelNet40'):
test_dataset = ModelNet40Dataset(config, train=False)
test_sampler = ModelNet40Sampler(test_dataset)
collate_fn = ModelNet40Collate
elif config.dataset == 'S3DIS':
test_dataset = S3DISDataset(config,
set='validation',
use_potentials=True)
test_sampler = S3DISSampler(test_dataset)
collate_fn = S3DISCollate
elif config.dataset == 'SemanticKitti':
test_dataset = SemanticKittiDataset(config,
set=set,
balance_classes=False)
test_sampler = SemanticKittiSampler(test_dataset)
collate_fn = SemanticKittiCollate
elif config.dataset == 'Fluo-C3DH-A549':
test_dataset = CellDataset(config, set='test', use_potentials=True)
test_sampler = CellDataSampler(test_dataset)
collate_fn = CellDataCollate
elif config.dataset == 'APRPointCloud':
test_dataset = APRPointCloudDataset(config,
set='test',
use_potentials=True)
test_sampler = APRPointCloudSampler(test_dataset)
collate_fn = APRPointCloudCollate
else:
raise ValueError('Unsupported dataset : ' + config.dataset)
# Data loader
test_loader = DataLoader(test_dataset,
batch_size=1,
collate_fn=collate_fn,
sampler=test_sampler,
num_workers=config.input_threads)
print('\nModel Preparation')
print('*****************')
# Define network model
t1 = time.time()
if config.dataset_task == 'classification':
net = KPCNN(config)
elif config.dataset_task in ['cloud_segmentation', 'slam_segmentation']:
net = KPFCNN(config, test_dataset.label_values,
test_dataset.ignored_labels)
else:
raise ValueError('Unsupported dataset_task for testing: ' +
config.dataset_task)
# Define a visualizer class
tester = ModelTester(net, chkp_path=chosen_chkp)
print('Done in {:.1f}s\n'.format(time.time() - t1))
print('\nStart Prediction')
print('**********\n')
# Training
if config.dataset_task == 'classification':
a = 1 / 0
elif config.dataset_task == 'cloud_segmentation':
tester.cloud_segmentation_test(net, test_loader, config)
elif config.dataset_task == 'slam_segmentation':
tester.slam_segmentation_test(net, test_loader, config)
else:
raise ValueError('Unsupported dataset_task for testing: ' +
config.dataset_task)
print('\nEnd Prediction')
print('**********\n')
# model initialization
config.architecture = [
'simple',
'resnetb',
]
for i in range(config.num_layers - 1):
config.architecture.append('resnetb_strided')
config.architecture.append('resnetb')
config.architecture.append('resnetb')
for i in range(config.num_layers - 2):
config.architecture.append('nearest_upsample')
config.architecture.append('unary')
config.architecture.append('nearest_upsample')
config.architecture.append('last_unary')
config.model = KPFCNN(config).to(config.device)
# create dataset and dataloader
info_train = load_obj(config.train_info)
train_set = IndoorDataset(info_train, config, data_augmentation=True)
demo_set = ThreeDMatchDemo(config, config.src_pcd, config.tgt_pcd)
_, neighborhood_limits = get_dataloader(
dataset=train_set,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.num_workers,
)
demo_loader, _ = get_dataloader(dataset=demo_set,
batch_size=config.batch_size,
shuffle=False,
