def read_datum(self, key):
"""Read in the GraspableObject3D corresponding to given key."""
if key not in self.data_keys_:
raise ValueError('Key %s not found in dataset %s' %
(key, self.name))
file_root = os.path.join(self.dataset_root_dir_, key)
sdf_filename = Dataset.sdf_filename(file_root)
obj_filename = Dataset.obj_filename(file_root)
features_filename = Dataset.features_filename(file_root)
# read in data
sf = sdf_file.SdfFile(sdf_filename)
sdf = sf.read()
of = obj_file.ObjFile(obj_filename)
mesh = of.read()
if os.path.exists(features_filename):
ff = feature_file.LocalFeatureFile(features_filename)
features = ff.read()
else:
features = None
return go.GraspableObject3D(sdf,
mesh=mesh,
features=features,
key=key,
model_name=obj_filename,
category=self.data_categories_[key])
def extract(self, graspable, feature_file_name):
""" Returns a set of extracted SHOT features for a graspable """
# make OS call to extract features to disk
shot_os_call = 'bin/shot_extractor %s %s' % (graspable.model_name,
feature_file_name)
os.system(shot_os_call)
# add features to graspable and return
feature_file = ff.LocalFeatureFile(feature_file_name)
shot_features = feature_file.read()
graspable.features[SHOTFeatureExtractor.key] = shot_features
def generate_shot_features(self):
""" Extracts SHOT features """
# extract shot features to the filesystem
shot_os_call = 'bin/shot_extractor %s %s' %(self.obj_filename, self.shot_filename)
os.system(shot_os_call)
# read the features back in
self.shot_features_ = None
try:
lff = feature_file.LocalFeatureFile(self.shot_filename)
self.shot_features_ = lff.read()
except Exception as e:
logging.warning('Failed to load SHOT features')
return self.shot_features_
def test_new_feature_matching():
a_features_filename = "data/test/features/pepper_orig_features.txt"
b_features_filename = "data/test/features/pepper_tf_features.txt"
a_mesh_filename = "data/test/features/pepper_orig.obj"
b_mesh_filename = "data/test/features/pepper_tf.obj"
# read data
a_feat_file = ff.LocalFeatureFile(a_features_filename)
a_features = a_feat_file.read()
b_feat_file = ff.LocalFeatureFile(b_features_filename)
b_features = b_feat_file.read()
a_obj_file = of.ObjFile(a_mesh_filename)
a_mesh = a_obj_file.read()
b_obj_file = of.ObjFile(b_mesh_filename)
b_mesh = b_obj_file.read()
# match features
feat_matcher = fm.RawDistanceFeatureMatcher()
ab_corrs = feat_matcher.match(a_features, b_features)
reg_solver = reg.RigidRegistrationSolver()
tf = reg_solver.register(ab_corrs)
# compare with true transform
tf_true = np.loadtxt("data/test/features/tf_true.txt", delimiter=" ")
delta_tf = tf.dot(np.linalg.inv(tf_true))
print 'Estimated TF'
print tf
print 'True TF'
print tf_true
print 'Delta TF'
print delta_tf
def get_feature(object):
feat_file = ffile.LocalFeatureFile(object[0])
return feat_file.read()
def zca_from_shot(feature_dir, num_samples_per_shape=75, num_clusters=25):
num_shapes = 0
feature_count = 0
b = fs.BagOfFeatures()
feat_filenames = []
cat_filenames = []
# walk through directory, adding files to feature rep
for root, sub_folders, files in os.walk(feature_dir):
for f in files:
file_name = os.path.join(root, f)
file_root, file_ext = os.path.splitext(file_name)
if file_ext == '.cat':
cat_filenames.append(file_name)
file_name = file_root + '_features.txt'
feat_filenames.append(file_name)
print 'Processing file %s (%d of %d)' % (
feat_filenames[-1], num_shapes, len(files) / 2)
# read features
feat_file = ff.LocalFeatureFile(file_name)
features = feat_file.read()
# get a random subset of features
num_features = features.descriptors.shape[0]
num_samples = min(num_samples_per_shape, num_features)
indices = np.random.choice(num_features,
num_samples,
replace=False)
descriptor_subset = features.descriptors[indices, :]
if num_shapes == 0:
feature_dim = features.descriptors.shape[1]
mu = np.zeros(feature_dim)
Sigma = np.zeros([feature_dim, feature_dim])
# update data matrix, mean, covariance estimates
new_feature_count = feature_count + num_samples
old_weight = float(feature_count) / float(new_feature_count)
new_weight = float(num_samples) / float(new_feature_count)
b.extend(features.feature_subset(indices))
mu = old_weight * mu + new_weight * np.sum(descriptor_subset,
axis=0)
Sigma = old_weight * Sigma + new_weight * descriptor_subset.T.dot(
descriptor_subset)
num_shapes += 1
feature_count += num_samples
# if num_shapes >= 200:
# break
# preprocessing transform with zca whitening
print 'Learning ZCA'
z = ZcaTransform()
z.fit_bootstrapped(mu, Sigma)
# lear feature dict with kmeans
print 'Learning dict'
k = KMeansFeatureDictionary(num_clusters, preprocess_fn=z)
k.fit(b)
# loop through objects and transform
shape_reps = np.zeros([len(feat_filenames), num_clusters])
categories = []
i = 0
print 'Repping shapes'
for feat_file_name, cat_file_name in zip(feat_filenames, cat_filenames):
print 'Repping ', feat_file_name
cat_file = open(cat_file_name, 'r')
cat = cat_file.readline()
feat_file = ff.LocalFeatureFile(feat_file_name)
features = feat_file.read()
shape_rep = k.transform(features)
shape_reps[i, :] = shape_rep
categories.append(cat)
i += 1
# transform everything for plotting
cat_list = list(set(categories))
cat_indices = [cat_list.index(c) for c in categories]
colors = plt.get_cmap('jet')(np.linspace(0, 1.0, len(cat_list)))
pointwise_colors = colors[cat_indices, :]
p = sd.PCA()
shapes_proj = p.fit_transform(shape_reps)
shapes_tf = shapes_proj[:, :2]
# plot all points
patches = []
for i in range(len(cat_list)):
patches.append(mpatches.Patch(color='red', label=cat_list[i]))
cat_array = np.array(cat_indices)
objs = []
plt.figure()
for i in range(len(cat_list)):
cat_ind = np.where(cat_array == i)
cat_ind = cat_ind[0]
o = plt.scatter(shapes_tf[cat_ind, 0],
shapes_tf[cat_ind, 1],
c=colors[i])
objs.append(o)
plt.legend(objs, cat_list)
plt.show()
f = open('shot_feature_dict.pkl', 'w')
pkl.dump(k, f)
# nearest neighbors queries
train_pct = 0.75
num_pts = len(categories)
all_indices = np.linspace(0, num_pts - 1, num_pts)
train_indices = np.random.choice(num_pts,
np.floor(train_pct * num_pts),
replace=False)
test_indices = np.setdiff1d(all_indices, train_indices)
train_indices = train_indices.astype(np.int16)
test_indices = test_indices.astype(np.int16)
train_categories = []
for i in range(train_indices.shape[0]):
train_categories.append(categories[train_indices[i]])
test_categories = []
for i in range(test_indices.shape[0]):
test_categories.append(categories[test_indices[i]])
# nearest neighbors
num_nearest = 5
nn = kernels.NearPy()
nn.train(shape_reps[train_indices, :], k=num_nearest)
# setup confusion
confusion = {}
confusion[UNKNOWN_TAG] = {}
for query_cat in cat_list:
confusion[query_cat] = {}
for query_cat in confusion.keys():
for pred_cat in cat_list:
confusion[query_cat][pred_cat] = 0
# get test confusion matrix
for i in range(test_indices.shape[0]):
true_category = categories[test_indices[i]]
[indices, dists] = nn.nearest_neighbors(shape_reps[test_indices[i], :],
k=num_nearest,
return_indices=True)
neighbor_cats = []
for index in indices:
neighbor_cats.append(categories[train_indices[index]])
print 'Shape nearest neighbors', true_category, neighbor_cats
if len(indices) > 0:
confusion[true_category][neighbor_cats[0]] += 1
else:
confusion[true_category][UNKNOWN_TAG] += 1
# accumulate results
# convert the dictionary to a numpy array
row_names = confusion.keys()
confusion_mat = np.zeros([len(row_names), len(row_names)])
i = 0
for query_cat in confusion.keys():
j = 0
for pred_cat in confusion.keys():
confusion_mat[i, j] = confusion[query_cat][pred_cat]
j += 1
i += 1
# get true positives, etc for each category
num_preds = len(test_files)
tp = np.diag(confusion_mat)
fp = np.sum(confusion_mat, axis=0) - np.diag(confusion_mat)
fn = np.sum(confusion_mat, axis=1) - np.diag(confusion_mat)
tn = num_preds * np.ones(tp.shape) - tp - fp - fn
# compute useful statistics
recall = tp / (tp + fn)
tnr = tn / (fp + tn)
precision = tp / (tp + fp)
npv = tn / (tn + fn)
fpr = fp / (fp + tn)
accuracy = np.sum(
tp) / num_preds # correct predictions over entire dataset
# remove nans
recall[np.isnan(recall)] = 0
tnr[np.isnan(tnr)] = 0
precision[np.isnan(precision)] = 0
npv[np.isnan(npv)] = 0
fpr[np.isnan(fpr)] = 0
IPython.embed()
"""