def dev(opt):
dev_dataset = PartDataset(root = '/mnt/lustre/niuyazhe/data/BDCI/dev_set/', classification = False, train = False)
dev_dataloader = torch.utils.data.DataLoader(dev_dataset, batch_size=opt.batchsize,
shuffle=False, num_workers=int(opt.workers))
num_classes = dataset.num_seg_classes
num_points = dataset.num_points
print(len(train_dataset), len(dev_dataset))
print('classes', num_classes)
print('points', num_points)
blue = lambda x:'\033[94m' + x + '\033[0m'
net = PointNetSeg(k = num_classes)
net = nn.DataParallel(net.cuda())
if opt.dev_model != '':
net.load_state_dict(torch.load(opt.dev_model))
net.eval()
for i, data in enumerate(dev_dataloader, 0):
points, target = data
target = target.long()
points, target = Variable(points).cuda(), Variable(target).cuda()
output, transform = net(points)
output_choice = output.data.max(2)[1]
correct = output_choice.eq(target.data).cpu().sum()
print('[%s: %d/%d] %s accuracy: %f' %("dev", i, num_batch, blue('test'), correct.item()/float(opt.batchSize * num_points)))
for i in range(1,8):
continue
pts_kept = []
circle_radius = random.randint(1, 3)
i = np.random.choice(len(pts))
random_pt = pts[i]
new_pts = []
for pt_idx, point in enumerate(pts):
if np.linalg.norm(point - random_pt) > circle_radius:
new_pts.append(point)
pts_kept.append(pt_idx)
return np.array(new_pts), pts_kept
dataset = PartDataset(root='demo_data',
task='multi_task',
npoints=opt.num_points,
mode='test',
min_pts=0,
num_seg_class=5,
load_in_memory=False)
cls_class_to_idx = dataset.classes
cls_idx_to_class = {v: k for k, v in dataset.classes.items()}
idx = opt.idx
print("model %d/%d" % (idx, len(dataset)))
point, cls, seg = dataset[idx]
damaged_point, pt_idx = get_damaged_points(point.numpy())
damaged_point = torch.from_numpy(damaged_point)
damaged_seg = seg[pt_idx]
parser.add_argument('--outf', type=str, default='cls', help='output folder')
parser.add_argument('--model', type=str, default = '', help='model path')
parser.add_argument('--n_views', type=int, default = 13, help='view numbers')
parser.add_argument('--lr', type=float, default = 0.01, help='learning rate')
parser.add_argument('--momentum', type=float, default = 0.9, help='momentum')
opt = parser.parse_args()
print (opt)
blue = lambda x:'\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root = 'shapenetcore_partanno_segmentation_benchmark_v0', classification = True, npoints = opt.num_points)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
test_dataset = PartDataset(root = 'shapenetcore_partanno_segmentation_benchmark_v0', classification = True, train = False, npoints = opt.num_points)
testdataloader = torch.utils.data.DataLoader(test_dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
print(len(dataset), len(test_dataset))
num_classes = len(dataset.classes)
print('classes', num_classes)
try:
os.makedirs(opt.outf)
except OSError:
pass
parser.add_argument('--num_points', type=int, default = 2500, help='number of points')
parser.add_argument('--dataset', type=str, required=True, help='dataset root')
parser.add_argument('--class_choice', type=str, required=True, help='class choice')
parser.add_argument('--noise_vec_size', type=int, default=100, help='size of noise vector')
opt = parser.parse_args()
print (opt)
blue = lambda x:'\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root = opt.dataset, class_choice = [opt.class_choice], classification = True)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
cudnn.benchmark = True
num_classes = len(dataset.classes)
try:
os.makedirs(opt.outf)
except OSError:
pass
classifier = PointNetCls(k = 2, num_points = opt.num_points)
parser.add_argument('--workers', type=int, help='number of data loading workers', default=0)
parser.add_argument('--nepoch', type=int, default=30, help='number of epochs to train for')
parser.add_argument('--outf', type=str, default='seg', help='output folder')
parser.add_argument('--model', type=str, default= '', help='model path')
opt = parser.parse_args()
print (opt)
opt.manualSeed = random.randint(1, 2500) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
num_points = 2700
dataset = PartDataset(root = 'shapenetcore_partanno_segmentation_benchmark_v0', npoints=num_points, classification=False, class_choice=['Chair'])
dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
test_dataset = PartDataset(root = 'shapenetcore_partanno_segmentation_benchmark_v0', npoints=num_points, classification=False, class_choice=['Chair'], train=False)
testdataloader = torch.utils.data.DataLoader(test_dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
print(len(dataset), len(test_dataset))
num_classes = 10
print('classes', num_classes)
try:
os.makedirs(opt.outf)
except OSError:
pass
help='number of epochs to train for')
parser.add_argument('--outf', type=str, default='gan', help='output folder')
parser.add_argument('--model', type=str, default='', help='model path')
opt = parser.parse_args()
print(opt)
blue = lambda x: '\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root='shapenetcore_partanno_segmentation_benchmark_v0',
class_choice=['Chair'],
classification=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
test_dataset = PartDataset(
root='shapenetcore_partanno_segmentation_benchmark_v0',
class_choice=['Chair'],
classification=True,
train=False)
testdataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
default=25,
help='number of epochs to train for')
parser.add_argument('--nowepoch', type=int, default=0, help='current epoch')
parser.add_argument('--outf', type=str, default='seg', help='output folder')
parser.add_argument('--model', type=str, default='', help='model path')
parser.add_argument('--lr', type=float, default=0.01, help='learning rate')
opt = parser.parse_args()
print(opt)
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root='..//Thingi10K//sdf_polar', train=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
test_dataset = PartDataset(root='..//Thingi10K//sdf_polar', train=False)
testdataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
print(len(dataset), len(test_dataset))
try:
os.makedirs(opt.outf)
except OSError:
R = np.array(((ct, st, 0), (-st, ct, 0), (0, 0, 1)))
# Construct the rotation matrix ( V Transpose(V) - I ) R.
M = (np.outer(V, V) - np.eye(3)).dot(R)
return M
blue = lambda x:'\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root = opt.dataset, class_choice = [opt.class_choice], canonicalize=True, npoints = opt.num_points, train=not opt.test)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
opt.outf += "_" + opt.class_choice
# Create summary logger
writer = SummaryWriter("runs/" + opt.outf + "_" + str(time.time()))
cudnn.benchmark = True
num_classes = len(dataset.classes)
print('classes', num_classes)
try:
def validation_data_loader():
#_fname = '%s/data/x_y1_y2_idx_200_withoutnoise.h5'%root
_fname = '%s/data/x_y1_y2_idx_33_withoutnoise.h5'%root
dataset = PartDataset(_fname,1, conf.batch_size,train=False) #train=False
return DataLoader(dataset, batch_size=conf.batch_size,
shuffle=False, num_workers=conf.threads)
def training_data_loader():
#_fname = '%s/data/x_y1_y2_idx_2017060708_normalise.h5'%root
_fname = '%s/data/x_y1_y2_idx_33_withoutnoise.h5'%root
dataset = PartDataset(_fname,300, conf.batch_size,train=True) #train=True 3050
return DataLoader(dataset, batch_size=conf.batch_size,
shuffle=False, num_workers=conf.threads)
def main():
global args
opt = parser.parse_args()
print(opt)
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(
root='shapenetcore_partanno_segmentation_benchmark_v0',
pic2point=True,
npoints=opt.num_points)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
print("number of training data:" + str(len(dataset)))
test_dataset = PartDataset(
root='shapenetcore_partanno_segmentation_benchmark_v0',
pic2point=True,
train=False,
npoints=opt.num_points)
testdataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
print("number of training data:" + str(len(test_dataset)))
# creat model
print("model building...")
model = pic2points(num_points=opt.num_points)
model.cuda()
# load pre-existing weights
if opt.model != '':
model.load_state_dict(torch.load(opt.model))
optimizer = torch.optim.Adadelta(model.parameters(), weight_decay=1e-4)
num_batch = len(dataset) / opt.batchSize
print('training mode ------------------')
for epoch in range(opt.nepoch):
print("epoch:" + str(epoch))
for i, data in enumerate(dataloader, 0):
im, points = data
im, points = Variable(im), Variable(points)
im, points = im.cuda(), points.cuda()
pred = model(im)
loss = batch_NN_loss(pred, points).cuda()
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i % 50 is 0:
print("training loss is:" + str(loss.data[0]))
loss_test = 0
for i, data in enumerate(dataloader, 0):
im_test, points_test = data
im_test, points_test = Variable(im_test), Variable(points_test)
im_test, points_test = im_test.cuda(), points_test.cuda()
pred_test = model(im_test)
loss_test = batch_NN_loss(pred_test, points_test).cuda()
print("Testing loss is:" + str(loss_test.data[0]))
opt = parser.parse_args()
print(opt)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('using device: {}'.format(device))
blue = lambda x: '\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root='data/roofn3d_data_multitask_v1',
task='classification',
npoints=opt.num_points,
load_in_memory=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
test_dataset = PartDataset(root='data/roofn3d_data_multitask_v1',
task='classification',
train=False,
npoints=opt.num_points,
load_in_memory=True)
testdataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
R = np.array(((ct, st, 0), (-st, ct, 0), (0, 0, 1)))
# Construct the rotation matrix ( V Transpose(V) - I ) R.
M = (np.outer(V, V) - np.eye(3)).dot(R)
return M
blue = lambda x:'\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root = opt.dataset, class_choice = [opt.class_choice], classification = True, npoints = opt.num_points, train=not opt.test)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
opt.outf += "_" + opt.class_choice
# Create summary logger
writer = SummaryWriter("runs/" + opt.outf + "_" + str(time.time()))
num_classes = len(dataset.classes)
print('classes', num_classes)
try:
os.makedirs(opt.outf)
except OSError:
pass
from datasets import PartDataset
from pointnet import PointGen, PointGenC, PointGenComp
import torch.nn.functional as F
import matplotlib.pyplot as plt
#showpoints(np.random.randn(2500,3), c1 = np.random.uniform(0,1,size = (2500)))
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, default='', help='model path')
opt = parser.parse_args()
print(opt)
dataset = PartDataset(root='shapenetcore_partanno_segmentation_benchmark_v0',
class_choice=['Chair'],
shape_comp=True)
gen = PointGenComp()
gen.load_state_dict(torch.load(opt.model))
ld = len(dataset)
idx = np.random.randint(ld)
print(ld, idx)
_, part = dataset[idx]
sim_noise = Variable(torch.randn(2, 1024))
sim_noises = Variable(torch.zeros(30, 1024))
def dev(opt):
dev_dataset = PartDataset(root='/mnt/lustre/niuyazhe/', train=False)
dev_dataloader = torch.utils.data.DataLoader(dev_dataset,
batch_size=opt.batchsize,
shuffle=False,
num_workers=int(opt.workers))
num_classes = 8 #dev_dataset.num_seg_classes
batch_size = opt.batchsize
num_points = 52480
print('classes', num_classes)
net = PointNetSeg(num_class=num_classes)
net = nn.DataParallel(net.cuda())
if opt.dev_model != '':
net.load_state_dict(torch.load(opt.dev_model))
print('path{}'.format(opt.dev_model))
else:
raise BaseException("no pretrained model")
net.eval()
global_IOU = 0.
count = 0
for i, data in enumerate(dev_dataloader):
points, target = data
target = target.long()
points = points.permute(0, 2, 1)
target = target.cuda()
points = Variable(points).cuda()
output, _ = net(points)
print("inference over")
output_choice = output.data.max(2)[1]
correct = torch.eq(output_choice, target).sum()
print('accuracy: %f' % (correct / float(batch_size * num_points)))
local_IOU = 0.
val = 7
o1 = torch.eq(output_choice, 1)
t1 = torch.eq(target, 1)
up = (o1 & t1).sum()
div = (o1 | t1).sum()
print('up{}'.format(up))
print('div{}'.format(div))
if div == 0:
val -= 1
else:
r1 = up * 1.0 / div
local_IOU += r1
o1 = torch.eq(output_choice, 2)
t1 = torch.eq(target, 2)
div = (o1 | t1).sum()
if div == 0:
val -= 1
else:
r1 = ((o1 & t1).sum()) / div
local_IOU += r1
o1 = torch.eq(output_choice, 3)
t1 = torch.eq(target, 3)
div = (o1 | t1).sum()
if div == 0:
val -= 1
else:
r1 = ((o1 & t1).sum()) / div
local_IOU += r1
o1 = torch.eq(output_choice, 4)
t1 = torch.eq(target, 4)
div = (o1 | t1).sum()
if div == 0:
val -= 1
else:
r1 = ((o1 & t1).sum()) / div
local_IOU += r1
o1 = torch.eq(output_choice, 5)
t1 = torch.eq(target, 5)
div = (o1 | t1).sum()
if div == 0:
val -= 1
else:
r1 = ((o1 & t1).sum()) / div
local_IOU += r1
o1 = torch.eq(output_choice, 6)
t1 = torch.eq(target, 6)
div = (o1 | t1).sum()
if div == 0:
val -= 1
else:
r1 = ((o1 & t1).sum()) / div
local_IOU += r1
o1 = torch.eq(output_choice, 7)
t1 = torch.eq(target, 7)
div = (o1 | t1).sum()
if div == 0:
val -= 1
else:
r1 = ((o1 & t1).sum()) / div
local_IOU += r1
local_IOU /= val
global_IOU += local_IOU
count += 1
print("count:{}".format(count))
print("local IOU:{}".format(local_IOU))
if count == 1000:
break
print("global IOU:%.8f" % (global_IOU / count))
# In[ ]:
# General parameters
NUM_POINTS = 10000
MODEL_PATH = './cls_model.pth'
DATA_FOLDER = './shapenetcore_partanno_segmentation_benchmark_v0'
# download dataset and pre-trained model
download.download_contents()
# In[ ]:
# Create dataset object
test_dataset_seg = PartDataset(root=DATA_FOLDER,
train=False,
classification=False,
npoints=NUM_POINTS)
# Problem ontology
classes_dict = {
'Airplane': 0,
'Bag': 1,
'Cap': 2,
'Car': 3,
'Chair': 4,
'Earphone': 5,
'Guitar': 6,
'Knife': 7,
'Lamp': 8,
'Laptop': 9,
'Motorbike': 10,
parser = argparse.ArgumentParser()
parser.add_argument('--model',
type=str,
default='./seg/seg_model_29_0.810.pth',
help='model path')
parser.add_argument('--cat', type=str, default='tools', help='category name')
parser.add_argument('--idx', type=int, default=0, help='data index')
opt = parser.parse_args()
print(opt)
num_classes = 10
num_points = 2700
d = PartDataset(root='shapenetcore_partanno_segmentation_benchmark_v0',
npoints=num_points,
class_choice=opt.cat,
train=False)
idx = opt.idx
print("model %d/%d" % (idx, len(d)))
point_np, seg = d[idx]
point = torch.from_numpy(point_np)
point_np[:, 2] *= -1
cmap = plt.cm.get_cmap("hsv", 5)
cmap = np.array([cmap(i) for i in range(10)])[:, :3]
gt = cmap[seg - 1, :]
classifier = PointNetDenseCls(num_points=num_points, k=num_classes)
print(opt)
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print('using device: {}'.format(device))
model_dir = opt.outf
blue = lambda x: '\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root=os.path.join(opt.input_path, 'train'),
task='multi_task',
npoints=opt.num_points,
min_pts=0,
load_in_memory=True,
num_seg_class=5)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
val_dataset = PartDataset(root=os.path.join(opt.input_path, 'val'),
task='multi_task',
mode='val',
npoints=opt.num_points,
min_pts=0,
load_in_memory=True,
num_seg_class=5)
valdataloader = torch.utils.data.DataLoader(val_dataset,
opt.knn = 16 # yw
np.random.seed(100)
pt = np.random.rand(250, 3)
# fig = plt.figure()
# ax = fig.add_subplot(111,projection='3d')
#ax.scatter(pt[:,0],pt[:,1],pt[:,2])
#plt.show()
class_choice = 'Airplane'
pt_root = 'shapenetcore_partanno_segmentation_benchmark_v0'
npoints = 2500
shapenet_dataset = PartDataset(root=pt_root,
class_choice=class_choice,
classification=True,
train=True)
print('len(shapenet_dataset) :', len(shapenet_dataset))
dataloader = torch.utils.data.DataLoader(shapenet_dataset,
batch_size=1,
shuffle=False)
li = list(enumerate(dataloader))
print(len(li))
# ps,cls = shapenet_dataset[0]
# print('ps.size:',ps.size())
# print('ps.type:',ps.type())
# print('cls.size',cls.size())
# print('cls.type',cls.type())
from show3d_balls import *
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, default='', help='model path')
parser.add_argument('--idx', type=int, default=0, help='model index')
parser.add_argument('--className', type=str, default='Chair', help='number of classes')
parser.add_argument('--radius', type=int, default=2, help='radius of ball for visualization')
parser.add_argument('--cmap', type=str, default='hsv', help='valid matplotlib cmap')
parser.add_argument('--npoints', type=int, default=2500, help='points to sample')
opt = parser.parse_args()
idx = opt.idx
d = PartDataset(root='shapenetcore_partanno_segmentation_benchmark_v0', class_choice=[opt.className], train=False, npoints=2048)
print('model %d/%d' % (idx, len(d)))
num_class = d.num_classes
print('number of classes', num_class)
point, seg = d[idx]
point_np = point.numpy()
cmap = plt.cm.get_cmap(opt.cmap, 10)
cmap = np.array([cmap(i) for i in range(10)])[:, :3]
gt = cmap[seg.numpy()-1, :]
classifier = PointNetDenseCls(k=shapenet_labels[opt.className])
default=200,
help='number of epochs to train for')
parser.add_argument('--outf', type=str, default='seg', help='output folder')
parser.add_argument('--model', type=str, default='', help='model path')
numpoints = 2500
opt = parser.parse_args()
print(opt)
os.environ['CUDA_VISIBLE_DEVICES'] = '2'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
cate = 'Guitar'
train_dataset = PartDataset(root='test250',
npoints=numpoints,
class_choice=cate)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
test_dataset = PartDataset(root='test250',
npoints=numpoints,
class_choice=cate,
train=False)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
num_workers=int(opt.workers))
default=4)
parser.add_argument('--num_points',
type=int,
default=1000,
help='input batch size')
parser.add_argument('--min_points',
type=int,
default=0,
help='smallest point cloud')
opt = parser.parse_args()
test_dataset = PartDataset(root=os.path.join(opt.input_path, 'test'),
task='classification',
mode='test',
npoints=opt.num_points,
min_pts=0,
load_in_memory=True,
num_seg_class=5)
testdataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=opt.batchSize,
shuffle=False,
num_workers=opt.workers)
num_batch = len(test_dataset) / opt.batchSize
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
classifier = PointNetCls(k=len(test_dataset.classes)).to(device)
classifier.load_state_dict(torch.load(opt.model))
classifier.eval()
help='number of epochs to train for')
parser.add_argument('--outf', type=str, default='cls', help='output folder')
parser.add_argument('--model', type=str, default='', help='model path')
opt = parser.parse_args()
print(opt)
blue = lambda x: '\033[94m' + x + '\033[0m'
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root='/data2/leo/bop/bop_renderer/samples/cls/',
classification=True,
npoints=opt.num_points)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
test_dataset = PartDataset(root='/data2/leo/bop/bop_renderer/samples/cls/',
classification=True,
train=False,
npoints=opt.num_points)
testdataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
parser.add_argument('--batchSize', type=int, default=4, help='input batch size')
parser.add_argument('--workers', type=int, help='number of data loading workers', default=4)
parser.add_argument('--nepoch', type=int, default=25, help='number of epochs to train for')
parser.add_argument('--outf', type=str, default='seg', help='output folder')
parser.add_argument('--model', type=str, default = '', help='model path')
opt = parser.parse_args()
print (opt)
#opt.manualSeed = random.randint(1, 10000) # fix seed
#print("Random Seed: ", opt.manualSeed)
#random.seed(opt.manualSeed)
#torch.manual_seed(opt.manualSeed)
dataset = PartDataset( classification = False)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize,
shuffle=True)#, num_workers=int(opt.workers)
test_dataset = PartDataset( classification = False, class_choice = ['Chair'], train = False)
testdataloader = torch.utils.data.DataLoader(test_dataset, batch_size=opt.batchSize,
shuffle=True, num_workers=int(opt.workers))
print(len(dataset), len(test_dataset))
num_classes = dataset.num_seg_classes
print('classes', num_classes)
try:
os.makedirs(opt.outf)
except OSError:
pass
from pointnet import PointNetDenseCls
import torch.nn.functional as F
import matplotlib.pyplot as plt
#showpoints(np.random.randn(2500,3), c1 = np.random.uniform(0,1,size = (2500)))
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, default='', help='model path')
parser.add_argument('--idx', type=int, default=0, help='model index')
opt = parser.parse_args()
print(opt)
d = PartDataset(root='/media/cba62/Elements/PointNet_Data',
class_choice=['Chair'],
train=False)
idx = opt.idx
print("model %d/%d" % (idx, len(d)))
point, seg = d[idx]
print(point.size(), seg.size())
point_np = point.numpy()
cmap = plt.cm.get_cmap("hsv", 10)
cmap = np.array([cmap(i) for i in range(10)])[:, :3]
gt = cmap[seg.numpy() - 1, :]
help='Classification Category to train segmentation on')
parser.add_argument('--scoresFolder',
type=str,
default='scores/SixMolecules',
help='Folder for scores')
opt = parser.parse_args()
print(opt)
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
dataset = PartDataset(root='T2Dataset',
classification=False,
class_choice=opt.classification)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
test_dataset = PartDataset(root='T2Dataset',
classification=False,
class_choice=opt.classification,
train=False)
testdataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
x2 = F.relu(self.fc5(x))
x2 = F.relu(self.fc6(x2))
x2 = F.relu(self.fc7(x2))
x2 = self.fc8(x2)
offset = x2.view(batchsize, 4, 3)
return code, offset
gen = PointCodeGen()
gen.load_state_dict(torch.load(opt.model + 'G_40.pth'))
dataset = PartDataset(root='shapenetcore_partanno_segmentation_benchmark_v0',
class_choice=['Chair'],
parts_also=True,
npoints=2048)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=64,
shuffle=True,
num_workers=1)
ae.cuda()
gen.cuda()
bs = 32
sim_noise = Variable(torch.randn(bs, 100)).cuda()
fake, pos = gen(sim_noise)
fake = fake.contiguous()
pos = pos.contiguous()
from datasets import PartDataset
import torch
dataset = PartDataset(root='shapenetcore_partanno_segmentation_benchmark_v0',
classification=True,
npoints=2500)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=True,
num_workers=0)
for i, data in enumerate(dataloader, 0):
points, target = data
print points, points.shape, target
if i == 4:
break
from pointnet import PointNetDenseCls
import torch.nn.functional as F
import matplotlib.pyplot as plt
#showpoints(np.random.randn(2500,3), c1 = np.random.uniform(0,1,size = (2500)))
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, default='', help='model path')
parser.add_argument('--idx', type=int, default=0, help='model index')
opt = parser.parse_args()
print(opt)
d = PartDataset(root='shapenetcore_partanno_segmentation_benchmark_v0',
class_choice=['Chair'],
train=False)
idx = opt.idx
print("model %d/%d" % (idx, len(d)))
point, seg = d[idx]
print(point.size(), seg.size())
point_np = point.numpy()
cmap = plt.cm.get_cmap("hsv", 10)
cmap = np.array([cmap(i) for i in range(10)])[:, :3]
gt = cmap[seg.numpy() - 1, :]
import torch.nn.functional as F
#import matplotlib.pyplot as plt
#from mpl_toolkits.mplot3d import Axes3D
#showpoints(np.random.randn(2500,3), c1 = np.random.uniform(0,1,size = (2500)))
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, default = '', help='model path')
opt = parser.parse_args()
print (opt)
test_dataset = PartDataset(root = 'shapenetcore_partanno_segmentation_benchmark_v0' , train = False, classification = True)
testdataloader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle = False)
classifier = PointNetCls(k = len(test_dataset.classes))
classifier.cuda()
classifier.load_state_dict(torch.load(opt.model))
classifier.eval()
total_correct=0
total_count=0
for i, data in enumerate(testdataloader, 0):
points, target = data
points_input = points.cpu().numpy()
print points_input.shape
# points_input = points_input[:,::5,:]
