class TestExtractPredictorNet(test_util.TestCase):
@unittest.skipIf('ImageInput' not in workspace.RegisteredOperators(),
"Needs OpenCV")
def test_extract_simple(self):
from caffe2.python import brew
from caffe2.python.model_helper import ModelHelper, ExtractPredictorNet
model = ModelHelper(name="test", arg_scope={'order': 'NCHW'})
[data, label] = brew.image_input(
model,
"reader",
["xx/data", "label"],
is_test=1,
)
cnv = brew.conv(model, data, 'cnv', 32, 32, 4)
a = brew.fc(model, cnv, 'a', 100, 200)
pred = brew.fc(model, a, 'pred', 200, 5)
brew.softmax(model, [pred, label], "softmax")
(predict_net, export_blobs) = ExtractPredictorNet(
net_proto=model.net.Proto(),
input_blobs=["xx/data"],
output_blobs=["pred"],
renames={"xx/data": "image"},
)
export_blobs = set(export_blobs)
ops = list(predict_net.Proto().op)
for op in ops:
self.assertFalse(op.type == "Softmax")
self.assertFalse("xx/data" in op.input)
# Note: image input should not be included
self.assertEquals(ops[0].type, "Conv")
self.assertEquals(ops[1].type, "FC")
self.assertEquals(ops[2].type, "FC")
self.assertEquals(len(ops), 3)
# test rename happened
self.assertEquals(ops[0].input[0], "image")
# Check export blobs
self.assertTrue("image" not in export_blobs)
self.assertTrue("xx/data" not in export_blobs)
self.assertEqual(set([str(p) for p in model.params]), export_blobs)
# Check external inputs/outputs
self.assertTrue("image" in predict_net.Proto().external_input)
self.assertEquals(set(["pred"]),
set(predict_net.Proto().external_output))
self.assertEqual(
set(predict_net.Proto().external_input) -
set([str(p) for p in model.params]), set(["image"]))
def _get_unimplemented_ops(self):
"""
Returns a list of unimplemented ops' names.
Arguments:
Returns:
List of unimplemented ops' names.
"""
# get required op
ops = workspace.RegisteredOperators()
required_ops = set(ops)
# get unimplemented ops
unimplemented_ops = required_ops - set(self._get_supported_ops())
return sorted(list(unimplemented_ops))
def _get_supported_ops(self):
"""
Returns a list of supported ops' names.
Arguments:
Returns:
List of supported ops' names.
"""
ob = OpsBridge()
supported_ops = set([
name for name in dir(ob)
if name[:1] != "_" and name not in ob.__dict__
])
# common set
supported_ops &= set(workspace.RegisteredOperators())
return sorted(list(supported_ops))
scores = scores.ravel()
boxes = np.column_stack((x, y, x, y)).astype(dtype=np.float32)
boxes *= (2**level)
boxes += anchor[anchor_ids, :]
box_deltas = box_pred[0, anchor_ids, :, y, x]
pred_boxes = box_utils.bbox_transform(boxes, box_deltas)
pred_boxes = box_utils.clip_tiled_boxes(pred_boxes, im_info[0, :2])
boxes_exp = np.zeros((pred_boxes.shape[0], 5), dtype=np.float32)
boxes_exp[:, 0:4] = pred_boxes
boxes_exp[:, 4] = scores
# for i in range(num_cls):
# if stats_act[0, i] > 0:
# print('cls %d: %d' % (i+1, stats_act[0, i]))
np.testing.assert_allclose(boxes_act[:, :5],
boxes_exp,
rtol=1e-6,
atol=1e-6)
np.testing.assert_allclose(feats_act, feats_exp)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_detectron_ops()
utils.c2.import_custom_ops()
assert 'BoxesAndFeats' in workspace.RegisteredOperators()
unittest.main()
anchors = []
for lvl in range(min_level, max_level+1):
field_stride = 2 ** lvl
anchor_sizes = (cfg.FPN.RPN_ANCHOR_START_SIZE * 2.**(lvl - min_level), )
anchor_aspect_ratios = cfg.FPN.RPN_ASPECT_RATIOS
anchor = generate_anchors(
stride=field_stride,
sizes=anchor_sizes,
aspect_ratios=anchor_aspect_ratios
)
anchors.append(anchor.astype(np.float32))
boxes = self._run_cpu_testing(cls_probs, box_preds, anchors, im_info)
utils.vis.vis_one_image(im[:, :, ::-1],
'{:s}-cd-output'.format(im_name),
osp.join(root_dir, 'tests'),
boxes,
segms=None,
keypoints=None,
thresh=0.,
box_alpha=0.8,
dataset=dataset,
show_class=False)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_detectron_ops()
utils.c2.import_custom_ops()
assert 'GenerateProposalsSingleImage' in workspace.RegisteredOperators()
unittest.main()
workspace.FeedBlob('X', X)
workspace.FeedBlob('im_info', im_info)
workspace.FeedBlob('data', data)
workspace.RunOperatorOnce(op)
Y = workspace.FetchBlob('Y')
return Y
def test_image(self):
this_dir = osp.dirname(__file__)
X = cv2.imread(osp.join(this_dir, 'zerg.jpg')).astype(np.float32)
# to C, H, W
X = np.transpose(X, (2, 0, 1))
im_info = np.array([[508., 944., 1.], [127., 236., 1.]],
dtype=np.float32)
data = np.zeros([2, 1, 1000, 1000], dtype=np.float32)
Y = self._run_resize_memory_init_op_gpu(X, im_info, data)
Y_dump1 = np.transpose(Y[0, :], (1, 2, 0))
Y_dump2 = np.transpose(Y[1, :], (1, 2, 0))
cv2.imwrite(osp.join(this_dir, 'z1-output.jpg'), Y_dump1)
cv2.imwrite(osp.join(this_dir, 'z2-output.jpg'), Y_dump2)
return True
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'ResizeMemoryInit' in workspace.RegisteredOperators()
unittest.main()
B = np.random.randn(2, 3, 5).astype(np.float32)
self._run_test(A, B, check_grad=True)
def test_large_forward(self):
A = np.random.randn(2, 256, 42, 100).astype(np.float32)
B = np.random.randn(2, 256, 35, 87).astype(np.float32)
self._run_test(A, B)
A = np.random.randn(2, 256, 42, 87).astype(np.float32)
B = np.random.randn(2, 256, 35, 87).astype(np.float32)
self._run_test(A, B)
def test_size_exceptions(self):
A = np.random.randn(2, 256, 42, 86).astype(np.float32)
B = np.random.randn(2, 256, 35, 87).astype(np.float32)
with self.assertRaises(RuntimeError):
self._run_test(A, B)
A = np.random.randn(2, 255, 42, 88).astype(np.float32)
B = np.random.randn(2, 256, 35, 87).astype(np.float32)
with self.assertRaises(RuntimeError):
self._run_test(A, B)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
c2_utils.import_detectron_ops()
assert 'SpatialNarrowAs' in workspace.RegisteredOperators()
logging_utils.setup_logging(__name__)
unittest.main()
rois = rois / im_info[0, 2]
scores = rois[:, [0]]
scores[:] = 1.
boxes = rois[:, 1:]
cls_boxes = np.hstack([boxes, scores])
utils.vis.vis_one_image(im[:, :, ::-1],
'{:s}-gd-output'.format(im_name),
current_dir,
cls_boxes,
segms=None,
keypoints=None,
thresh=0.,
box_alpha=0.8,
dataset=dataset,
show_class=False)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_detectron_ops()
utils.c2.import_custom_ops()
assert 'SelectTopN' in workspace.RegisteredOperators()
assert 'SelectTopNSingle' in workspace.RegisteredOperators()
assert 'BoxesAndFeats' in workspace.RegisteredOperators()
assert 'ClassBasedBoxes' in workspace.RegisteredOperators()
assert 'ClassBasedBoxesSingle' in workspace.RegisteredOperators()
assert 'NMS' in workspace.RegisteredOperators()
assert 'ReduceBoxesAndFeats' in workspace.RegisteredOperators()
assert 'ReduceSumGPU' in workspace.RegisteredOperators()
unittest.main()
Y_exp = np.array([0, 1, 0, 3, 0], dtype=np.float32)
Y_act = self._run_zero_even_op_gpu(X)
np.testing.assert_allclose(Y_act[0::2], Y_exp[0::2])
def test_gpu_preserves_vals_at_odd_inds(self):
X = np.array([0, 1, 2, 3, 4], dtype=np.float32)
Y_exp = np.array([0, 1, 0, 3, 0], dtype=np.float32)
Y_act = self._run_zero_even_op_gpu(X)
np.testing.assert_allclose(Y_act[1::2], Y_exp[1::2])
def test_gpu_handles_even_length_arrays(self):
X = np.random.rand(64).astype(np.float32)
Y_exp = np.copy(X)
Y_exp[0::2] = 0.0
Y_act = self._run_zero_even_op_gpu(X)
np.testing.assert_allclose(Y_act, Y_exp)
def test_gpu_handles_odd_length_arrays(self):
X = np.random.randn(77).astype(np.float32)
Y_exp = np.copy(X)
Y_exp[0::2] = 0.0
Y_act = self._run_zero_even_op_gpu(X)
np.testing.assert_allclose(Y_act, Y_exp)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
c2_utils.import_custom_ops()
assert 'ZeroEven' in workspace.RegisteredOperators()
unittest.main()
rois = self._run_cpu_testing(cls_preds, cls_probs, box_preds, anchors, im_info)
rois = rois / im_info[0, 2]
scores = rois[:, [0]]
scores[:] = 1.
boxes = rois[:, 1:]
cls_boxes = np.hstack([boxes, scores])
utils.vis.vis_one_image(im[:, :, ::-1],
'{:s}-cd-output'.format(im_name),
current_dir,
cls_boxes,
segms=None,
keypoints=None,
thresh=0.,
box_alpha=0.8,
dataset=dataset,
show_class=False)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_detectron_ops()
utils.c2.import_custom_ops()
assert 'SelectTopN' in workspace.RegisteredOperators()
assert 'SelectTopNSingle' in workspace.RegisteredOperators()
assert 'BoxesOnly' in workspace.RegisteredOperators()
assert 'ClassBasedBoxesCombined' in workspace.RegisteredOperators()
assert 'NMSOnly' in workspace.RegisteredOperators()
assert 'ReduceBoxesOnly' in workspace.RegisteredOperators()
assert 'ReduceSumGPU' in workspace.RegisteredOperators()
assert 'Distribute' in workspace.RegisteredOperators()
unittest.main()
M = fun(unary, im)
print(M.shape, M.max(), M.min(), M.mean())
print(M.shape, M.max(), M.min(), M.mean())
aM = np.argmax(M, axis=1)
res = np.zeros((H, W, 3), dtype=np.uint8)
for h in range(H):
for w in range(W):
l = aM[0, h, w]
# l = lbl[h, w]
# print(M[0, :, h, w])
for key in label.keys():
if l == label[key][0]:
color = label[key][1]
res[h, w, :] = color
cv2.imwrite('build/im' + idx + '.png', res)
def test_handles_arrays(self):
self._test_handles_arrays('1', self._run_dense_crf_op)
self._test_handles_arrays('2', self._run_dense_crf_op)
def test_handles_arrays_gpu(self):
self._test_handles_arrays('3', self._run_dense_crf_op_gpu)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
c2_utils.import_custom_ops()
assert 'DenseCRF' in workspace.RegisteredOperators()
unittest.main()
c = X.shape[1]
nd = nc - 1
assert c % nd == 0
a = int(c / nd)
h = X.shape[2]
w = X.shape[3]
X = X.reshape(n*a, nd, h, w)
zerosX = np.zeros((n*a, 1, h, w), dtype=np.float32)
Xhat = np.concatenate([zerosX, X], axis=1)
maxX = Xhat.max(axis=1, keepdims=True)
Xhat -= maxX
Xhat = np.exp(Xhat)
sumX = Xhat.sum(axis=1, keepdims=True)
Y_exp = Xhat / sumX
Y_exp = Y_exp.reshape(n, a * (nd + 1), h, w)
np.testing.assert_allclose(Y_act, Y_exp, atol=1e-7)
def test_one_res(self):
X = np.random.rand(2, 1, 7, 7).astype(np.float32)
self._test_single_res(X)
def test_mult_res(self):
X = np.random.rand(20, 6, 8, 8).astype(np.float32)
self._test_mult_res(X, 3)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'AddSpatialSoftmax' in workspace.RegisteredOperators()
unittest.main()
from caffe2.proto import caffe2_pb2
from caffe2.python import core
from caffe2.python import workspace
import utils.c2
class MulConvFCOpTest(unittest.TestCase):
def _run_mul_conv_fc_op_gpu(self, X1, X2):
with core.DeviceScope(core.DeviceOption(caffe2_pb2.CUDA, 0)):
op = core.CreateOperator('MulConvFC', ['X1', 'X2'], ['Y'])
workspace.FeedBlob('X1', X1)
workspace.FeedBlob('X2', X2)
workspace.RunOperatorOnce(op)
Y = workspace.FetchBlob('Y')
return Y
def test_res(self):
X1 = np.random.rand(20, 512, 7, 7).astype(np.float32)
X2 = np.random.rand(20, 512).astype(np.float32)
Y_act = self._run_mul_conv_fc_op_gpu(X1, X2)
Y_exp = X1 * X2.reshape(20, 512, 1, 1)
np.testing.assert_allclose(Y_act, Y_exp)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'MulConvFC' in workspace.RegisteredOperators()
unittest.main()
for i in range(lx):
workspace.FeedBlob('X%d' % i, Xs[i])
workspace.RunOperatorOnce(op)
Y = workspace.FetchBlob('Y')
return Y
def test_res(self):
iter = 3
a = 1
x = 2048
Xs = []
for i in range(iter):
Xs.append(np.random.rand(2, a * x).astype(np.float32))
attention = np.random.rand(2, iter * a).astype(np.float32)
Y_act = self._run_reduce_with_attention_region_op_gpu(Xs, attention, iter)
A = attention.reshape(2, iter, a)
As = np.split(A, iter, axis=1)
As = [ sa.reshape(2, a, 1) for sa in As ]
Xs = [ xs.reshape(2, a, x) for xs in Xs ]
Y_exp = np.zeros_like(Xs[0])
for i in range(iter):
Y_exp += Xs[i] * As[i]
Y_exp = Y_exp.reshape(2, a * x)
np.testing.assert_allclose(Y_act, Y_exp, atol=1e-7)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'ReduceWithAttentionRegion' in workspace.RegisteredOperators()
unittest.main()
try:
from .libcaffe2_python import *
except ImportError as e:
print(str(e))
print('Pycaffe is not available. Exiting.')
sys.exit(1)
# libcaffe2_python contains a global Workspace that we need to properly delete
# when exiting. Otherwise, cudart will cause segfaults sometimes.
atexit.register(OnModuleExit)
from caffe2.proto import caffe2_pb2
from collections import Counter, defaultdict
from caffe2.python import utils, workspace
_REGISTERED_OPERATORS = set(
s.decode() for s in workspace.RegisteredOperators())
def IsOperator(op_type):
return (op_type in _REGISTERED_OPERATORS)
def GetGradientName(name):
"""The function that returns the gradient name for a blob."""
return name + '_grad'
def IsGradientName(name):
return name.endswith('_grad')
def GetOriginalName(name):
"""THe function that returns the original name for a gradient blob."""
if not name.endswith('_grad'):
raise RuntimeError('The blob ' + name + ' is not a legal gradient name.')
return rois
def test_do_detection(self):
cls_preds, cls_probs, box_preds, anchors, im_info, im, im_name, current_dir, dataset = self._test_std()
rois = self._run_op(cls_preds, cls_probs, box_preds, anchors, im_info)
rois = rois / im_info[0, 2]
scores = rois[:, [0]]
scores[:] = 1.
boxes = rois[:, 1:]
cls_boxes = np.hstack([boxes, scores])
utils.vis.vis_one_image(im[:, :, ::-1],
'{:s}-rd-output'.format(im_name),
current_dir,
cls_boxes,
segms=None,
keypoints=None,
thresh=0.,
box_alpha=0.8,
dataset=dataset,
show_class=False)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=-2'])
utils.c2.import_detectron_ops()
utils.c2.import_custom_ops()
assert 'RetinanetDetection' in workspace.RegisteredOperators()
unittest.main()
rois = rois / im_info[0, 2]
scores = rois[:, [0]]
scores[:] = 1.
boxes = rois[:, 1:]
cls_boxes = np.hstack([boxes, scores])
utils.vis.vis_one_image(im[:, :, ::-1],
'{:s}-gd-output'.format(im_name),
current_dir,
cls_boxes,
segms=None,
keypoints=None,
thresh=0.,
box_alpha=0.8,
dataset=dataset,
show_class=False)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_detectron_ops()
utils.c2.import_custom_ops()
assert 'SelectTopN' in workspace.RegisteredOperators()
assert 'SelectTopNSingle' in workspace.RegisteredOperators()
assert 'SelectBottomNSingle' in workspace.RegisteredOperators()
assert 'BoxesOnly' in workspace.RegisteredOperators()
assert 'ClassBasedBoxesOnly' in workspace.RegisteredOperators()
assert 'NMSOnly' in workspace.RegisteredOperators()
assert 'ReduceBoxesOnly' in workspace.RegisteredOperators()
assert 'ReduceSumGPU' in workspace.RegisteredOperators()
unittest.main()
score_index = i * 20 + pred_class
# print(label, type(label), label.shape)
if label==pred_class:
loss += -np.log(sigmoid(scores[0, score_index, 0, 0]))
else:
dis = 1
gt_center_index = (pred_class-14) * 2
if gt_centers[0, gt_center_index, 0, 0]!=-1:
gt_cx = gt_centers[0, gt_center_index, 0, 0]
gt_cy = gt_centers[0, gt_center_index+1, 0, 0]
anchor_x1, anchor_y1, anchor_x2, anchor_y2 = rois[0, i*5+1: i*5+5, 0, 0]
anchor_cx = anchor_x1 + (anchor_x2 - anchor_x1)/2
anchor_cy = anchor_y1 + (anchor_y2 - anchor_y1)/2
im_w = im_info[0, 0, 0, 0]
im_h = im_info[0, 1, 0, 0]
dis = np.sqrt( (gt_cx-anchor_cx)**2 + (gt_cy-anchor_cy)**2 )/ np.sqrt(im_w**2 + im_h**2)
loss += -np.log(1-sigmoid(scores[0, score_index, 0, 0])) * dis
print('loss:', loss)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
c2_utils.import_custom_ops()
assert 'SsDistanceLoss' in workspace.RegisteredOperators()
unittest.main()
# ss_test = SsDistanceLossOpTest()
# ss_test.test_small_forward_and_gradient()
def test_res(self):
rpn_rois, rpn_roi_probs, gt_boxes, gt_classes, im_info, im, im_name, root_dir, dataset = self._test_std(
)
rois, labels, bbox_targets, bbox_inside_weights, bbox_outside_weights = self._run_cpu_generate_labels(
rpn_rois, gt_boxes, gt_classes, im_info)
labels = labels.reshape(cfg.TRAIN.BATCH_SIZE_PER_IM, 1)
rois_idx, rois_shuffled = self._run_distribute(rois)
assert (rois_shuffled[rois_idx] == rois).all()
boxes_to_viz = np.hstack([rois[:, 1:5], labels.astype(np.float32)])
utils.vis.vis_one_image(im[:, :, ::-1],
'{:s}-lb-output'.format(im_name),
osp.join(root_dir, 'tests'),
boxes_to_viz,
segms=None,
keypoints=None,
thresh=0.,
box_alpha=0.8,
dataset=dataset,
show_class=False)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_detectron_ops()
utils.c2.import_custom_ops()
assert 'GenerateProposalsSingleImage' in workspace.RegisteredOperators()
assert 'GenerateProposalLabelsSingleImage' in workspace.RegisteredOperators(
)
assert 'DistributeFPN' in workspace.RegisteredOperators()
unittest.main()
import utils.c2
class ConcatAttentionOpTest(unittest.TestCase):
def _run_concat_attention_op_gpu(self, X1, X2):
with core.DeviceScope(core.DeviceOption(caffe2_pb2.CUDA, 0)):
op = core.CreateOperator('ConcatAttention', ['X1', 'X2'], ['Y'])
workspace.FeedBlob('X1', X1)
workspace.FeedBlob('X2', X2)
workspace.RunOperatorOnce(op)
Y = workspace.FetchBlob('Y')
return Y
def test_res(self):
X1 = np.random.rand(2, 270, 7, 7).astype(np.float32)
X2 = np.random.rand(2, 270, 7, 7).astype(np.float32)
Y_act = self._run_concat_attention_op_gpu(X1, X2)
Y_exp = np.empty((2, 540, 7, 7), dtype=np.float32)
Y_exp[:, 0::2, :, :] = X1
Y_exp[:, 1::2, :, :] = X2
np.testing.assert_allclose(Y_act, Y_exp)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'ConcatAttention' in workspace.RegisteredOperators()
unittest.main()
A = np.random.randn(2, 3, 5, 7).astype(np.float32)
I = np.array([0, 1], dtype=np.int32)
self._run_op_test(A, I, check_grad=True)
A = np.random.randn(2, 3, 5, 7).astype(np.float32)
I = np.array([1, 0], dtype=np.int32)
self._run_op_test(A, I, check_grad=True)
A = np.random.randn(10, 3, 5, 7).astype(np.float32)
I = np.array(np.random.permutation(10), dtype=np.int32)
self._run_op_test(A, I, check_grad=True)
def test_size_exceptions(self):
A = np.random.randn(2, 256, 42, 86).astype(np.float32)
I = np.array(np.random.permutation(10), dtype=np.int32)
with self.assertRaises(RuntimeError):
self._run_op_test(A, I)
# See doc string in _run_speed_test
# def test_perf(self):
# with core.DeviceScope(core.DeviceOption(caffe2_pb2.CUDA, 0)):
# self._run_speed_test()
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_detectron_ops()
assert 'BatchPermutation' in workspace.RegisteredOperators()
utils.logging.setup_logging(__name__)
unittest.main()
def calulate_Y(self, X, cout):
"""X shape: (N, H, W)
"""
n, h, w = X.shape
Y = np.zeros((n, cout, h, w), dtype=np.float32)
for i in range(n):
Y[i, :, :, :] = X[i, :, :]
# test Y if correct
# for i in range(n):
# for c in range(cout):
# print((Y[i, c, :, :]==X[i, :, :]).all())
Y = np.log(Y)
return Y
def calulate_Y( X, cout):
n, c, h, w = X.shape
Y = np.zeros((n, cout, h, w), dtype=np.float32)
sum_onehot = np.zeros((n, h, w), dtype=np.float32)
for i in range(c):
sum_onehot[:, :, :] += X[:, i, :, :]
for j in range(cout):
Y[:, j, :, :] = sum_onehot
return Y
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
c2_utils.import_custom_ops()
assert 'PoseLine' in workspace.RegisteredOperators()
unittest.main()
Y = workspace.FetchBlob('Y')
return Y
def test_image(self):
this_dir = osp.dirname(__file__)
X = cv2.imread(osp.join(this_dir, 'zerg.jpg')).astype(np.float32)
# to C, H, W
X = np.transpose(X, (2, 0, 1))
X = np.expand_dims(X, 0).astype(np.float32)
rois = np.array(
[[0., 10., 20., 400., 200.], [0., 300., 100., 470., 250.],
[0., -100., -20., 500., 300.]],
dtype=np.float32)
Y = self._run_crop_and_resize_op_gpu(X, rois)
Y_dump1 = np.transpose(Y[0, :], (1, 2, 0))
Y_dump2 = np.transpose(Y[1, :], (1, 2, 0))
Y_dump3 = np.transpose(Y[2, :], (1, 2, 0))
cv2.imwrite(osp.join(this_dir, 'car1-output.jpg'), Y_dump1)
cv2.imwrite(osp.join(this_dir, 'car2-output.jpg'), Y_dump2)
cv2.imwrite(osp.join(this_dir, 'car3-output.jpg'), Y_dump3)
return True
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'CropAndResize' in workspace.RegisteredOperators()
unittest.main()
workspace.FeedBlob('X', X)
workspace.FeedBlob('repeats', repeats)
workspace.RunOperatorOnce(op)
Y = workspace.FetchBlob('Y')
return Y
def test_random_input(self):
X = np.random.rand(3, 5)
Y_exp = np.repeat(np.copy(X), 3, axis=0)
Y_act = self._run_repeat_op(X, np.array([3], dtype=np.int32))
np.testing.assert_allclose(Y_act, Y_exp)
def test_gpu_random_input(self):
X = np.random.rand(3, 5)
Y_exp = np.repeat(np.copy(X), 3, axis=0)
Y_act = self._run_repeat_op_gpu(X, np.array([3], dtype=np.int32))
np.testing.assert_allclose(Y_act, Y_exp)
def test_gradient(self):
G = np.random.rand(12, 5).astype(np.float32)
Y_exp = self._run_repeat_grad_op_np(G.copy(), 3)
Y_act = self._run_repeat_grad_op(G, 3)
np.testing.assert_allclose(Y_act, Y_exp)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
c2_utils.import_custom_ops()
assert 'Repeat' in workspace.RegisteredOperators()
unittest.main()
def _GetRegisteredOperators():
return set(s.decode() for s in workspace.RegisteredOperators())
['Y_hat', 'Y', 'inside_weights', 'outside_weights'], ['loss'],
scale=scale,
beta=beta)
gc = gradient_checker.GradientChecker(stepsize=0.005,
threshold=0.005,
device_option=core.DeviceOption(
caffe2_pb2.CUDA, 0))
res, grad, grad_estimated = gc.CheckSimple(
op, [Y_hat, Y, inside_weights, outside_weights], 0, [0])
self.assertTrue(grad.shape == grad_estimated.shape,
'Fail check: grad.shape != grad_estimated.shape')
# To inspect the gradient and estimated gradient:
# np.set_printoptions(precision=3, suppress=True)
# print('grad:')
# print(grad)
# print('grad_estimated:')
# print(grad_estimated)
self.assertTrue(res)
if __name__ == '__main__':
c2_utils.import_detectron_ops()
assert 'SmoothL1Loss' in workspace.RegisteredOperators()
logging_utils.setup_logging(__name__)
unittest.main()
from __future__ import print_function
from __future__ import unicode_literals
import atexit
import sys
from collections import namedtuple
from ._import_c_extension import *
from caffe2.proto import caffe2_pb2
from collections import Counter, defaultdict
from caffe2.python import utils, workspace
import logging
_REGISTERED_OPERATORS = set(s.decode() for s in workspace.RegisteredOperators())
def IsOperator(op_type):
return (op_type in _REGISTERED_OPERATORS)
# The name scope and device scope when creating a new operator.
_NAMESCOPE = ''
_DEVICESCOPE = None
class NameScope(object):
"""Helper class to create embedded name scopes."""
# SEPARATOR is defined to be "/" so it is consistent with TensorFlow's
# visualization tools.
SEPARATOR = '/'
def __init__(self, prefix):
op = core.CreateOperator('SelectTopN', ['X'], ['YI', 'YV'],
top_n=top_n)
workspace.FeedBlob('X', X)
workspace.RunOperatorOnce(op)
YI = workspace.FetchBlob('YI')
YV = workspace.FetchBlob('YV')
return YI, YV
def test_res(self):
top_n = 1000
X = np.random.rand(1, 720, 20, 30).astype(np.float32) * 100.
YI_act, YV_act = self._run_select_top_n_op_gpu(X, top_n)
YI_act.sort()
YV_act.sort()
Xr = X.ravel()
YI_exp = np.argpartition(Xr, top_n)[:top_n]
YV_exp = Xr[YI_exp]
YI_exp.sort()
YV_exp.sort()
np.testing.assert_allclose(YI_act, YI_exp)
np.testing.assert_allclose(YV_act, YV_exp)
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'SelectTopN' in workspace.RegisteredOperators()
unittest.main()
return Y_hat
def _run_resize_pil(self, X, h, w):
X_hat = X[0, :]
X_hat = np.transpose(X_hat, (1, 2, 0))
X_hat = Image.fromarray(X_hat.astype(np.uint8))
Y_hat = X_hat.resize((w, h), Image.BILINEAR)
Y_hat = np.array(Y_hat)
Y_hat = np.transpose(Y_hat.astype(np.float32), (2, 0, 1))
Y_hat = np.expand_dims(Y_hat, 0)
return Y_hat
def test_image(self):
this_dir = osp.dirname(__file__)
X = cv2.imread(osp.join(this_dir, 'zerg.jpg'))
X = np.transpose(X, (2, 0, 1))
X = np.expand_dims(X, 0).astype(np.float32)
Y = self._run_resize_bilinear_op_gpu(X, 508, 944)
Y_dump = np.transpose(Y[0, :], (1, 2, 0))
cv2.imwrite(osp.join(this_dir, 'zerg-output.jpg'), Y_dump)
# Y_hat = self._run_resize_cv2(X, 508, 944)
return True
if __name__ == '__main__':
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
utils.c2.import_custom_ops()
assert 'ResizeBilinear' in workspace.RegisteredOperators()
unittest.main()
