def vis(args):
test_data, test_label = load_data(root, train=False)
log.info(test_data=test_data.shape, test_label=test_label.shape)
log.debug('Building Model', args.model_name)
if args.model_name == 'pointnet':
num_class = 40
model = PointNetCls(num_class, args.feature_transform).cuda()
else:
model = PointNet2ClsMsg().cuda()
torch.backends.cudnn.benchmark = True
model = torch.nn.DataParallel(model)
model.cuda()
log.info('Using multi GPU:', args.gpu)
if args.pretrain is None:
log.err('No pretrain model')
return
log.debug('Loading pretrain model...')
checkpoint = torch.load(args.pretrain)
model.load_state_dict(checkpoint)
model.eval()
log.info('Press space to exit, press Q for next frame')
for idx in range(test_data.shape[0]):
point_np = test_data[idx:idx + 1]
gt = test_label[idx][0]
points = torch.from_numpy(point_np)
points = points.transpose(2, 1).cuda()
pred, trans_feat = model(points)
pred_choice = pred.data.max(1)[1]
log.info(gt=class_names[gt],
pred_choice=class_names[pred_choice.cpu().numpy().item()])
point_cloud = open3d.geometry.PointCloud()
point_cloud.points = open3d.utility.Vector3dVector(point_np[0])
vis = open3d.visualization.VisualizerWithKeyCallback()
vis.create_window()
vis.get_render_option().background_color = np.asarray([0, 0, 0])
vis.add_geometry(point_cloud)
vis.register_key_callback(32, lambda vis: exit())
vis.run()
vis.destroy_window()
def evaluate(args):
test_data, test_label = load_data(
'experiment/data/modelnet40_ply_hdf5_2048/', train=False)
testDataset = ModelNetDataLoader(test_data, test_label)
testDataLoader = torch.utils.data.DataLoader(testDataset,
batch_size=args.batch_size,
shuffle=False)
log.debug('Building Model', args.model_name)
if args.model_name == 'pointnet':
num_class = 40
model = PointNetCls(num_class, args.feature_transform)
else:
model = PointNet2ClsMsg()
torch.backends.cudnn.benchmark = True
model = torch.nn.DataParallel(model).cuda()
log.debug('Using gpu:', args.gpu)
if args.pretrain is None:
log.err('No pretrain model')
return
log.debug('Loading pretrain model...')
state_dict = torch.load(args.pretrain)
model.load_state_dict(state_dict)
acc = test_clf(model.eval(), testDataLoader)
log.msg(Test_Accuracy='%.5f' % (acc))
# import torch.nn.functional as F
import numpy as np
import sys
from os import path
from model.pointnet import PointNetCls
import torch.multiprocessing as mp
sys.path.append(path.dirname(path.dirname(path.abspath("__file__"))))
# torch.cuda.manual_seed(1) # don't delete
grasp_points_num = 1024
model = PointNetCls(num_points=grasp_points_num, input_chann=3, k=2)
model.cuda()
model.eval()
torch.set_grad_enabled(False)
def load_weight(weights_path):
print('[Python] Load weight: {}'.format(weights_path))
model.load_state_dict(torch.load(weights_path))
def classify_pcs(local_pcs, output_cls=0):
""" Classify point clouds FPS:650 """
print("[Python] Classify point clouds...")
# print(local_pcs)
# print(local_pcs.shape)
def main():
''' --- SELECT DEVICES --- '''
# Select either gpu or cpu
device = torch.device("cuda" if args.cuda else "cpu")
# Select among available GPUs
if args.cuda:
os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(
str(x) for x in args.gpudevice)
''' --- INIT NETWORK MODEL --- '''
projdir = sys.path[0]
# Path for saving and loading the network.
saveloadpath = os.path.join(projdir, 'experiment\\checkpoints',
args.exp_name + '.pth')
Path(os.path.dirname(saveloadpath)).mkdir(exist_ok=True, parents=True)
# Load selected network model and put it to right device
if args.model_name == 'pointnet':
classifier = PointNetCls(dim=args.pointCoordDim,
num_class=len(args.categories),
feature_transform=args.feature_transform)
elif args.model_name == 'pointnet2':
classifier = PointNet2ClsMsg(dim=args.pointCoordDim,
num_class=len(args.categories))
else:
raise Exception(
'Argument "model_name" does not match existent networks')
classifier = classifier.to(device)
''' --- LOAD NETWORK IF EXISTS --- '''
if os.path.exists(saveloadpath):
print('Using pretrained model found...')
checkpoint = torch.load(saveloadpath)
start_epoch = checkpoint[
'epoch'] + 1 # Just becase make sure counting starts from 1, 2, ..., rather than 0, 1, ..., when print the information of start_epoch
iteration = checkpoint['iteration']
best_test_acc = checkpoint['test_accuracy']
classifier.load_state_dict(checkpoint['model_state_dict'])
else:
raise Exception('Model in: {} does not exists'.format(saveloadpath))
# put classifier in evaluation mode
classifier = classifier.eval()
''' --- INIT DATASETS AND DATALOADER (FOR SINGLE EPOCH) --- '''
# Ideal for PointNet and pointLSTM - dataloader will return (B:batch, S:seq, C:features, N:points)
dataTransformations = transforms.Compose([
ToSeries(),
DataAugmentation(),
Resampling(maxPointsPerFrame=10),
ToTensor()
])
# init dataset
nusc = NuScenes(version=args.nuscenes_eval_dir,
dataroot=args.nuscenes_dir,
verbose=True)
''' Iterate over samples '''
idx = list(range(len(nusc.sample)))
random.shuffle(idx) # shuffle samples
# for sample_rec in nusc.sample:
for i in idx:
sample_rec = nusc.sample[i]
sample_token = sample_rec['token']
# read all sensors data and merge them to a common reference frame
sensorlist = []
for sensor in args.sensors:
sensorlist.append(
MyRadarPointCloud.from_sample_token(nusc, sample_token,
sensor))
global radar_pc
radar_pc = MyRadarPointCloud.merge(sensorlist, 0)
# get annotations for actual sample
ann_tokens = nusc.get('sample', sample_token)['anns']
# filter annotations that are objects of interest for our classifier
def get_ann_properties(nusc, ann_token: str):
ann_rec = nusc.get('sample_annotation', ann_token)
category = ann_rec['category_name']
attr_tokens = ann_rec['attribute_tokens']
attr = [
nusc.get('attribute', attr_token)['name']
for attr_token in attr_tokens
]
if len(attr) == 0: attr = ['']
print('object category:{:30} attr:{:40} center:{:20}'.format(
category, str(attr),
str(ann_rec['translation'] - radar_pc.A_cs_2_gl[:3, 3])))
return category, attr[
0] # for now lets return only the first attribute (we might have more per object)
def isInterestingObject(ann_token):
cat, att = get_ann_properties(nusc, ann_token)
# category-attribute pair must match at least one of the desired category-attr pair
for desired_cat, desired_att in zip(args.categories,
args.attributes):
if cat in desired_cat and att in desired_att:
return True
return False
print('\n\nGround-truth objects on this frame:')
ann_tokens = list(filter(isInterestingObject, ann_tokens))
def getObjLabel(ann_token):
cat, att = get_ann_properties(nusc, ann_token)
for idx, (desired_cat, desired_att) in enumerate(
zip(args.categories, args.attributes)):
if cat in desired_cat and att in desired_att:
return idx
return np.NaN
labels = list(map(getObjLabel, ann_tokens))
assert np.all(
~np.isnan(labels)
), 'Something strange happened... object was selected as interesting but we can not find its label'
# create bounding boxes from annotations
ann_boxes = []
for ann_token, label in zip(ann_tokens, labels):
box = radar_pc.box(ann_token)
box.label = label
box.name = args.objectNames[label]
ann_boxes.append(box)
''' APPLY DBSCAN ON EACH SCENE'''
from sklearn.cluster import DBSCAN
points_scene = radar_pc.points # points_gl = <5,N>
# filter out objects, whose speed is less than 0.3 m/s
idx_moving = np.linalg.norm(points_scene[2:4, :].T, axis=1) > 0.25
points_scene = points_scene[:, idx_moving]
# apply DBSCAN
clustering = DBSCAN(eps=3, min_samples=1).fit(points_scene[:2, :].T)
''' For each cluster, run network and predict class '''
pred_results = []
for cluster_idx in range(max(clustering.labels_)):
# select points from the current cluster
points_idx = clustering.labels_ == cluster_idx
points_obj = points_scene[:, points_idx]
# apply necessary transformations
features = dataTransformations(points_obj)
# convert to torch.tensor
features = torch.tensor(features).type(
torch.FloatTensor).unsqueeze(0).to(device)
# calculate network prediction
pred = classifier(features).argmax().item()
# store result
pred_results.append((points_obj, pred))
''' RENDER '''
OBJCOLORS = ['red', 'green', 'blue', 'grey', 'orange', 'white']
fig = plt.figure(constrained_layout=True)
gs = GridSpec(2, 6, figure=fig)
gs.update(wspace=0, hspace=0)
axs = [
fig.add_subplot(gs[1, :3]),
fig.add_subplot(gs[1, 3:]),
fig.add_subplot(gs[0, 0]),
fig.add_subplot(gs[0, 1]),
fig.add_subplot(gs[0, 2]),
fig.add_subplot(gs[0, 3]),
fig.add_subplot(gs[0, 4]),
fig.add_subplot(gs[0, 5])
]
# render annotation boxes
for box in ann_boxes:
color = OBJCOLORS[box.label]
box.render(axs[0], colors=(color, ) * 3)
box.render(axs[1], colors=(color, ) * 3)
# render cars
radar_pc.car.render(axs[0], colors=('orange', 'k', 'k'))
radar_pc.car.render(axs[1], colors=('orange', 'k', 'k'))
# render pointcloud
radar_pc._render_pc(axs[0], radar_pc.points, color_channel='k')
for cluster_points, pred in pred_results:
# radar_pc._render_pc( axs[1], cluster_points, color_channel=OBJCOLORS[pred])
if pred != 5:
axs[1].scatter(cluster_points[0, :],
cluster_points[1, :],
s=30,
c=OBJCOLORS[pred],
edgecolors='k',
linewidths=1,
zorder=100)
# plot ellipses
if cluster_points.shape[1] > 1:
confidence_ellipse(axs[1],
cluster_points[0, :],
cluster_points[1, :],
edgecolor=OBJCOLORS[pred],
facecolor=OBJCOLORS[pred],
alpha=0.5)
# render camera images
cameras = [
'CAM_BACK_LEFT', 'CAM_FRONT_LEFT', 'CAM_FRONT', 'CAM_FRONT_RIGHT',
'CAM_BACK_RIGHT', 'CAM_BACK'
]
for ax_idx, cam_name in enumerate(cameras):
cam_token = sample_rec['data'][cam_name]
cam_rec = nusc.get('sample_data', cam_token)
img_filename = os.path.join(nusc.dataroot, cam_rec['filename'])
img = mpimg.imread(img_filename)
# axs[ax_idx].set_axis_off()
axs[ax_idx + 2].get_xaxis().set_visible(False)
axs[ax_idx + 2].get_yaxis().set_visible(False)
axs[ax_idx + 2].imshow(img)
axs[ax_idx + 2].set_title(cam_name)
# format
legend_elements = [
Line2D([0], [0], color=color, lw=4, label=name)
for color, name in zip(OBJCOLORS, args.objectNames)
]
axs[0].legend(handles=legend_elements,
loc='upper right',
prop={'size': 8})
axs[1].legend(handles=legend_elements,
loc='upper right',
prop={'size': 8})
axs[0].axis('equal')
axs[1].axis('equal')
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
plt.tight_layout()
lims = (-60, 60)
axs[0].set_xlim(lims)
axs[0].set_ylim(lims)
axs[0].set_title(
'Radar detection points and ground truth bounding boxes of MOVING objects'
)
axs[1].set_xlim(lims)
axs[1].set_ylim(lims)
axs[1].set_title(
'Segmented segmentation of detection points (DBSCAN + PointNet classifier)\n3-sigma ellipses for each cluster and ground-truth bbs'
)
plt.tight_layout()
plt.show()
# plot scene with the standard Nuscenes method
# nusc.render_sample(sample_token)
# plt.show()
# sample_token = nusc.get('sample', sample_token)['next']
tb_writer.close()
def main(args):
'''HYPER PARAMETER'''
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
# datapath = './data/ModelNet/'
datapath = './data/objecnn20_data_hdf5_2048/'
if args.rotation is not None:
ROTATION = (int(args.rotation[0:2]),int(args.rotation[3:5]))
else:
ROTATION = None
'''CREATE DIR'''
experiment_dir = Path('./experiment/')
experiment_dir.mkdir(exist_ok=True)
file_dir = Path(str(experiment_dir) +'/%sObjectNNClf-'%args.model_name+ str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M')))
file_dir.mkdir(exist_ok=True)
checkpoints_dir = file_dir.joinpath('checkpoints/')
checkpoints_dir.mkdir(exist_ok=True)
log_dir = file_dir.joinpath('logs/')
log_dir.mkdir(exist_ok=True)
'''LOG'''
args = parse_args()
logger = logging.getLogger(args.model_name)
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler = logging.FileHandler(str(log_dir) + '/train_%s_ObjectNNClf.txt'%args.model_name)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.info('---------------------------------------------------TRANING---------------------------------------------------')
logger.info('PARAMETER ...')
logger.info(args)
'''DATA LOADING'''
logger.info('Load dataset ...')
train_data, train_label, test_data, test_label = load_data(datapath, classification=True)
logger.info("The number of training data is: %d",train_data.shape[0])
logger.info("The number of test data is: %d", test_data.shape[0])
trainDataset = ObjectNNDataLoader(train_data, train_label, rotation=ROTATION)
if ROTATION is not None:
print('The range of training rotation is',ROTATION)
testDataset = ObjectNNDataLoader(test_data, test_label, rotation=ROTATION)
trainDataLoader = torch.utils.data.DataLoader(trainDataset, batch_size=args.batchsize, shuffle=True)
testDataLoader = torch.utils.data.DataLoader(testDataset, batch_size=args.batchsize, shuffle=False)
'''MODEL LOADING'''
num_class = 20
classifier = PointNetCls(num_class,args.feature_transform).cuda() if args.model_name == 'pointnet' else PointNet2ClsMsg().cuda()
if args.pretrain is not None:
print('Use pretrain model...')
logger.info('Use pretrain model')
checkpoint = torch.load(args.pretrain)
start_epoch = checkpoint['epoch']
# classifier.load_state_dict(checkpoint['model_state_dict'])
# print(checkpoint['model_state_dict'])
model_dict = classifier.state_dict()
pretrained_dict = {k: v for k, v in checkpoint['model_state_dict'].items() if k in model_dict}
model_dict.update(pretrained_dict)
classifier.load_state_dict(model_dict)
else:
print('No existing model, starting training from scratch...')
start_epoch = 0
if args.optimizer == 'SGD':
optimizer = torch.optim.SGD(classifier.parameters(), lr=0.01, momentum=0.9)
elif args.optimizer == 'Adam':
optimizer = torch.optim.Adam(
classifier.parameters(),
lr=args.learning_rate,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=args.decay_rate
)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5) # 调整学习率
global_epoch = 0
global_step = 0
best_tst_accuracy = 0.0
blue = lambda x: '\033[94m' + x + '\033[0m'
'''TRANING'''
logger.info('Start training...')
for epoch in range(start_epoch,args.epoch):
print('Epoch %d (%d/%s):' % (global_epoch + 1, epoch + 1, args.epoch))
logger.info('Epoch %d (%d/%s):' ,global_epoch + 1, epoch + 1, args.epoch)
scheduler.step()
for batch_id, data in tqdm(enumerate(trainDataLoader, 0), total=len(trainDataLoader), smoothing=0.9):
points, target = data
target = target[:, 0]
points = points.transpose(2, 1)
points, target = points.cuda(), target.cuda()
optimizer.zero_grad()
classifier = classifier.train()
pred, trans_feat, global_feature = classifier(points)
loss = F.nll_loss(pred, target.long())
if args.feature_transform and args.model_name == 'pointnet':
loss += feature_transform_reguliarzer(trans_feat) * 0.001
loss.backward()
optimizer.step()
global_step += 1
train_acc = test(classifier.eval(), trainDataLoader) if args.train_metric else None
acc = test(classifier, testDataLoader)
print('\r Loss: %f' % loss.data)
logger.info('Loss: %.2f', loss.data)
if args.train_metric:
print('Train Accuracy: %f' % train_acc)
logger.info('Train Accuracy: %f', (train_acc))
print('\r Test %s: %f' % (blue('Accuracy'),acc))
logger.info('Test Accuracy: %f', acc)
if (acc >= best_tst_accuracy) and epoch > 5:
best_tst_accuracy = acc
logger.info('Save model...')
save_checkpoint(
global_epoch + 1,
train_acc if args.train_metric else 0.0,
acc,
classifier,
optimizer,
str(checkpoints_dir),
args.model_name)
print('Saving model....')
global_epoch += 1
print('Best Accuracy: %f'%best_tst_accuracy)
logger.info('End of training...')
def main(testDataset):
args = parse_args()
'''HYPER PARAMETER'''
# os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu if args.multi_gpu is None else '0,1,2,3'
datapath = './data/ModelNet/'
if args.rotation is not None:
ROTATION = (int(args.rotation[0:2]),int(args.rotation[3:5]))
else:
ROTATION = None
'''CREATE DIR'''
experiment_dir = Path('./experiment/')
experiment_dir.mkdir(exist_ok=True)
checkpoints_dir = Path('./experiment/checkpoints/')
checkpoints_dir.mkdir(exist_ok=True)
log_dir = Path('./experiment/logs/')
log_dir.mkdir(exist_ok=True)
'''LOG'''
args = parse_args()
logger = logging.getLogger("PointNet2")
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler = logging.FileHandler('./experiment/logs/train_%s_'%args.model_name+ str(datetime.datetime.now().strftime('%Y-%m-%d %H-%M'))+'.txt')
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.info('---------------------------------------------------TRANING---------------------------------------------------')
logger.info('PARAMETER ...')
logger.info(args)
'''DATA LOADING'''
logger.info('Load dataset ...')
# train_data, train_label, test_data, test_label = load_data(datapath, classification=True)
# logger.info("The number of training data is: %d",train_data.shape[0])
# logger.info("The number of test data is: %d", test_data.shape[0])
# trainDataset = ModelNetDataLoader(train_data, train_label, rotation=ROTATION)
#if ROTATION is not None:
# print('The range of training rotation is',ROTATION)
# testDataset = ModelNetDataLoader(test_data, test_label, rotation=ROTATION)
# trainDataLoader = torch.utils.data.DataLoader(trainDataset, batch_size=args.batchsize, shuffle=True)
testDataLoader = torch.utils.data.DataLoader(testDataset, batch_size=args.batchsize, shuffle=False)
'''MODEL LOADING'''
num_class = 40
classifier = PointNetCls(num_class,args.feature_transform).cuda() if args.model_name == 'pointnet' else PointNet2ClsMsg().cuda()
'''GPU selection and multi-GPU'''
if args.multi_gpu is not None:
device_ids = [int(x) for x in args.multi_gpu.split(',')]
torch.backends.cudnn.benchmark = True
classifier.cuda(device_ids[0])
classifier = torch.nn.DataParallel(classifier, device_ids=device_ids)
else:
classifier.cuda()
''' 使用预训练模型 '''
if args.pretrain is not None:
print('Use pretrain model...')
logger.info('Use pretrain model')
checkpoint = torch.load(args.pretrain)
start_epoch = checkpoint['epoch']
classifier.load_state_dict(checkpoint['model_state_dict'])
else:
print('No existing model, starting training from scratch...')
start_epoch = 0
if args.optimizer == 'SGD':
optimizer = torch.optim.SGD(classifier.parameters(), lr=0.01, momentum=0.9)
elif args.optimizer == 'Adam':
optimizer = torch.optim.Adam(
classifier.parameters(),
lr=args.learning_rate,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=args.decay_rate
)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5)
global_epoch = 0
global_step = 0
best_tst_accuracy = 0.0
blue = lambda x: '\033[94m' + x + '\033[0m'
start_epoch = 0
args.epoch = 1
'''TRANING'''
logger.info('Start training...')
for epoch in range(start_epoch,args.epoch):
print('Epoch %d (%d/%s):' % (global_epoch + 1, epoch + 1, args.epoch))
logger.info('Epoch %d (%d/%s):' ,global_epoch + 1, epoch + 1, args.epoch)
# scheduler.step()
# for batch_id, data in tqdm(enumerate(trainDataLoader, 0), total=len(trainDataLoader), smoothing=0.9):
# points, target = data
# target = target[:, 0]
# points = points.transpose(2, 1)
# points, target = points.cuda(), target.cuda()
# optimizer.zero_grad()
# classifier = classifier.train()
# pred, trans_feat = classifier(points)
# loss = F.nll_loss(pred, target.long())
# if args.feature_transform and args.model_name == 'pointnet':
# loss += feature_transform_reguliarzer(trans_feat) * 0.001
# loss.backward()
# optimizer.step()
# global_step += 1
train_acc = test(classifier.eval(), trainDataLoader) if args.train_metric else None
acc, fts = test(classifier, testDataLoader)
# return fts
# print('\r Loss: %f' % loss.data)
# logger.info('Loss: %.2f', loss.data)
if args.train_metric:
print('Train Accuracy: %f' % train_acc)
logger.info('Train Accuracy: %f', (train_acc))
print('\r Test %s: %f' % (blue('Accuracy'),acc))
logger.info('Test Accuracy: %f', acc)
return fts
if (acc >= best_tst_accuracy) and epoch > 5:
best_tst_accuracy = acc
logger.info('Save model...')
save_checkpoint(
global_epoch + 1,
train_acc if args.train_metric else 0.0,
acc,
classifier,
optimizer,
str(checkpoints_dir),
args.model_name)
print('Saving model....')
global_epoch += 1
print('Best Accuracy: %f'%best_tst_accuracy)
logger.info('End of training...')
def main(args):
'''HYPER PARAMETER'''
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
# datapath = './data/ModelNet/'
datapath = './data/modelnet40_ply_hdf5_2048/'
if args.rotation is not None:
ROTATION = (int(args.rotation[0:2]), int(args.rotation[3:5]))
else:
ROTATION = None
'''CREATE DIR'''
experiment_dir = Path('./experiment/')
experiment_dir.mkdir(exist_ok=True)
checkpoints_dir = Path('./experiment/checkpoints/')
checkpoints_dir.mkdir(exist_ok=True)
log_dir = Path('./experiment/logs/')
log_dir.mkdir(exist_ok=True)
'''LOG'''
args = parse_args()
logger = logging.getLogger("PointNet2")
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler = logging.FileHandler(
'./experiment/logs/test_%s_' % args.model_name +
str(datetime.datetime.now().strftime('%Y-%m-%d %H-%M')) + '.txt')
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.info(
'---------------------------------------------------Test---------------------------------------------------'
)
logger.info('PARAMETER ...')
logger.info(args)
'''DATA LOADING'''
logger.info('Load dataset ...')
train_data, train_label, test_data, test_label = load_data(
datapath, classification=True)
logger.info("The number of training data is: %d", train_data.shape[0])
logger.info("The number of test data is: %d", test_data.shape[0])
trainDataset = ModelNetDataLoader(train_data,
train_label,
rotation=ROTATION)
if ROTATION is not None:
print('The range of training rotation is', ROTATION)
testDataset = ModelNetDataLoader(test_data, test_label, rotation=ROTATION)
trainDataLoader = torch.utils.data.DataLoader(trainDataset,
batch_size=args.batchsize,
shuffle=True)
testDataLoader = torch.utils.data.DataLoader(testDataset,
batch_size=args.batchsize,
shuffle=False) # 不打乱
'''MODEL LOADING'''
num_class = 40
###################### PointNetCls ######################
classifier = PointNetCls(num_class, args.feature_transform).cuda(
) if args.model_name == 'pointnet' else PointNet2ClsMsg().cuda()
if args.pretrain is not None:
print('Use pretrain model...')
logger.info('Use pretrain model')
checkpoint = torch.load(args.pretrain)
start_epoch = checkpoint['epoch']
classifier.load_state_dict(checkpoint['model_state_dict'])
else:
print('Please Input the pretrained model ***.pth')
return
if args.optimizer == 'SGD':
optimizer = torch.optim.SGD(classifier.parameters(),
lr=0.01,
momentum=0.9)
elif args.optimizer == 'Adam':
optimizer = torch.optim.Adam(classifier.parameters(),
lr=args.learning_rate,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=args.decay_rate)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=20,
gamma=0.5)
global_epoch = 0
global_step = 0
best_tst_accuracy = 0.0
blue = lambda x: '\033[94m' + x + '\033[0m'
'''TestING'''
logger.info('Start testing...')
scheduler.step()
acc = test(classifier.eval(), testDataLoader)
print('\r Test %s: %f' % (blue('Accuracy'), acc))
logger.info('Test Accuracy: %f', acc)
logger.info('End of testing...')
def main(args):
'''HYPER PARAMETER'''
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
# datapath = './data/ModelNet/'
datapath = './data/objecnn20_data_hdf5_2048/'
if args.rotation is not None:
ROTATION = (int(args.rotation[0:2]), int(args.rotation[3:5]))
else:
ROTATION = None
'''CREATE DIR'''
experiment_dir = Path('./experiment/')
experiment_dir.mkdir(exist_ok=True)
file_dir = Path(
str(experiment_dir) + '/Test_%sObjectNNClf-' % args.model_name +
str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M')))
file_dir.mkdir(exist_ok=True)
checkpoints_dir = file_dir.joinpath('checkpoints/')
checkpoints_dir.mkdir(exist_ok=True)
log_dir = file_dir.joinpath('logs/')
log_dir.mkdir(exist_ok=True)
'''LOG'''
args = parse_args()
logger = logging.getLogger(args.model_name)
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler = logging.FileHandler(
str(log_dir) + '/test_%s_ObjectNNClf.txt' % args.model_name)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.info(
'---------------------------------------------------Test---------------------------------------------------'
)
logger.info('PARAMETER ...')
logger.info(args)
'''DATA LOADING'''
logger.info('Load dataset ...')
database_data, database_label, query_data, query_label = load_data(
datapath, classification=True)
print(">>>>>>>>>database_data:", database_data.shape)
print(">>>>>>>>>query_data:", query_data.shape)
logger.info("The number of database_data data is: %d",
database_data.shape[0])
logger.info("The number of query_data data is: %d", query_data.shape[0])
###################### 加载 database 和 query ######################
databaseDataset = TestQueryObjectNNDataLoader(database_data,
database_label,
rotation=ROTATION)
if ROTATION is not None:
print('The range of training rotation is', ROTATION)
queryDataset = TestQueryObjectNNDataLoader(query_data,
query_label,
rotation=ROTATION)
databaseDataLoader = torch.utils.data.DataLoader(databaseDataset,
batch_size=args.batchsize,
shuffle=False)
queryDataLoader = torch.utils.data.DataLoader(queryDataset,
batch_size=args.batchsize,
shuffle=False) # 不打乱
'''MODEL LOADING'''
num_class = 20
###################### PointNetCls ######################
classifier = PointNetCls(num_class, args.feature_transform).cuda(
) if args.model_name == 'pointnet' else PointNet2ClsMsg().cuda()
# classifier = PointNetCls(num_class,args.feature_transform) if args.model_name == 'pointnet' else PointNet2ClsMsg()
if args.pretrain is not None:
print('Use pretrain model...')
logger.info('Use pretrain model')
checkpoint = torch.load(args.pretrain)
start_epoch = checkpoint['epoch']
classifier.load_state_dict(checkpoint['model_state_dict'])
else:
print('Please Input the pretrained model ***.pth')
return
if args.optimizer == 'SGD':
optimizer = torch.optim.SGD(classifier.parameters(),
lr=0.01,
momentum=0.9)
elif args.optimizer == 'Adam':
optimizer = torch.optim.Adam(classifier.parameters(),
lr=args.learning_rate,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=args.decay_rate)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=20,
gamma=0.5)
global_epoch = 0
global_step = 0
best_tst_accuracy = 0.0
blue = lambda x: '\033[94m' + x + '\033[0m'
'''QueryING'''
logger.info('Start query...')
scheduler.step()
###################### Query ######################
classifier.eval()
_acc, database_feature_martix = getGlobalFeature('database',
classifier.eval(),
databaseDataLoader)
_acc, query_feature_martix = getGlobalFeature('query', classifier.eval(),
queryDataLoader)
