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()