from caffe2.python import core, workspace from caffe2.python.core import CreatePythonOperator import caffe2.python.hypothesis_test_util as hu from hypothesis import given, settings import hypothesis.strategies as st import numpy as np class CustomError(Exception): pass def SubFunctionThatThrowsCustomError(): raise CustomError("This is an intentional exception.") def MainOpFunctionThatThrowsCustomError(inputs, _): return SubFunctionThatThrowsCustomError() def MainOpFunctionThatThrowsCustomErrorInBuilder(inputs, _): raise CustomError("This is an intentional exception in builder.") def op_builder(name, index, extra): iterations = [0] assert name == 'name' assert index == 5 assert extra - 4.2 < 0.0001 def my_op(inputs, outputs): assert inputs[0].data[0] == iterations[0] assert name == 'name' assert index == 5 assert extra - 4.2 < 0.0001 iterations[0] += 1 return my_op class PythonOpTest(hu.HypothesisTestCase): @given(x=hu.tensor()) def test_feed(self, x): def f(inputs, _): self.assertEqual(x.shape, inputs[0].shape) self.assertEqual(type(inputs[0].shape), tuple) self.assertEqual(type(inputs[0].data), np.ndarray) np.testing.assert_almost_equal(x, inputs[0].data) op = CreatePythonOperator(f, ["x"], []) workspace.FeedBlob("x", x) workspace.RunOperatorOnce(op) def test_exception(self): op = CreatePythonOperator(MainOpFunctionThatThrowsCustomError, [], []) with self.assertRaisesRegex(CustomError, "This is an intentional exception."): workspace.RunOperatorOnce(op) def test_exception_builder(self): op = CreatePythonOperator(MainOpFunctionThatThrowsCustomErrorInBuilder, [], []) with self.assertRaisesRegex(CustomError, "This is an intentional exception in builder."): workspace.RunOperatorOnce(op) @given(x=hu.tensor()) def test_feed_with_helper_function(self, x): def f(inputs, _): self.assertEqual(x.shape, inputs[0].shape) self.assertEqual(type(inputs[0].shape), tuple) self.assertEqual(type(inputs[0].data), np.ndarray) np.testing.assert_almost_equal(x, inputs[0].data) net = core.Net("test") net.Python(f)(["x"], []) workspace.FeedBlob("x", x) workspace.RunNetOnce(net) def test_builder_tuple(self): net = core.Net("builder_template") iter_blob = 'iter' net.Python((op_builder, ['name', 5], {'extra': 4.2}))([iter_blob], []) net.Python((op_builder, ['name', 5], {'extra': 4.2}))([iter_blob], []) for repeat in range(2): # check that the builder will be called exactly once for each # PythonOp constructor. Cloning the net will also trigger a call # to the builder when the net is created. cloned_net = net.Clone('builder_%d' % repeat) workspace.FeedBlob(iter_blob, np.array([0])) # Builder gets called once per python op in the line below workspace.CreateNet(cloned_net) for i in range(10): workspace.FeedBlob(iter_blob, np.array([i])) workspace.RunNet(cloned_net) @given(x=hu.tensor()) def test_feed_with_gc(self, x): def f(inputs, _): self.assertEqual(x.shape, inputs[0].shape) np.testing.assert_almost_equal(x, inputs[0].data) op = CreatePythonOperator(f, ["x"], []) workspace.FeedBlob("x", x) workspace.RunOperatorOnce(op) del f workspace.FeedBlob("x", x) workspace.RunOperatorOnce(op) @given(x=hu.tensor()) def test_reshape(self, x): def f(inputs, outputs): outputs[0].reshape(inputs[0].shape) self.assertEqual(x.shape, inputs[0].shape) self.assertEqual(x.shape, outputs[0].shape) outputs[0].data[...] = inputs[0].data op = CreatePythonOperator(f, ["x"], ["y"]) workspace.FeedBlob("x", x) workspace.RunOperatorOnce(op) y = workspace.FetchBlob("y") np.testing.assert_almost_equal(x, y) @given(x=hu.tensor()) def test_workspace_manipulation(self, x): """ Verify that python op can manipulate workspace directly """ def f(inputs, outputs, ws): fetched = ws.blobs['internal'].fetch() np.testing.assert_almost_equal(fetched, x) ws = workspace.C.Workspace() net = core.Net("test") net.GivenTensorFill([], ['internal'], values=x, shape=x.shape) net.Python(f, pass_workspace=True)([], []) ws.run(net) @given(x=hu.tensor()) def test_caught_exception_doesnt_terminate(self, x): def f(inputs, outputs): try: raise Exception("Exception in handler") except Exception: pass op = CreatePythonOperator(f, ["x"], ["y"]) workspace.FeedBlob("x", x) workspace.RunOperatorOnce(op) @given(x=hu.tensor(), n=st.integers(min_value=1, max_value=20), w=st.integers(min_value=1, max_value=20)) @settings(deadline=1000) def test_multithreaded_evaluation(self, x, n, w): def f(inputs, outputs): outputs[0].reshape(inputs[0].shape) outputs[0].data[...] = inputs[0].data ops = [CreatePythonOperator(f, ["x"], [str(i)]) for i in range(n)] net = core.Net("net") net.Proto().op.extend(ops) net.Proto().type = "dag" net.Proto().num_workers = w iters = 100 plan = core.Plan("plan") plan.AddStep(core.ExecutionStep("test-step", net, iters)) workspace.FeedBlob("x", x) workspace.RunPlan(plan.Proto().SerializeToString()) for i in range(n): y = workspace.FetchBlob(str(i)) np.testing.assert_almost_equal(x, y) @given(x=hu.tensor(), in_place=st.booleans(), **hu.gcs) @settings(deadline=10000) def test_gradient(self, x, in_place, gc, dc): def f(inputs, outputs): outputs[0].reshape(inputs[0].shape) outputs[0].data[...] = inputs[0].data * 2 def grad_f(inputs, outputs): # Ordering is [inputs, outputs, grad_outputs] grad_output = inputs[2] grad_input = outputs[0] grad_input.reshape(grad_output.shape) grad_input.data[...] = grad_output.data * 2 op = CreatePythonOperator( f, ["x"], ["x" if in_place else "y"], grad_f=grad_f) self.assertGradientChecks(gc, op, [x], 0, [0]) self.assertDeviceChecks(dc, op, [x], [0]) @given(inputs=hu.tensors(n=2), **hu.gcs) @settings(deadline=10000) def test_gradient_multiple(self, inputs, gc, dc): (x1, x2) = inputs def f(inputs, outputs): for idx in [0, 1]: self.assertEqual(type(inputs[idx].shape), tuple) outputs[idx].reshape(inputs[idx].shape) outputs[idx].data[...] = inputs[idx].data * 2 def grad_f(inputs, outputs): # Ordering is [inputs, outputs, grad_outputs] self.assertEqual(len(inputs), 6) self.assertEqual(len(outputs), 2) for (grad_output_idx, grad_input_idx) in [(4, 0), (5, 1)]: grad_output = inputs[grad_output_idx] grad_input = outputs[grad_input_idx] grad_input.reshape(grad_output.shape) grad_input.data[...] = grad_output.data * 2 op = CreatePythonOperator(f, ["x1", "x2"], ["y1", "y2"], grad_f=grad_f) for idx in [0, 1]: self.assertGradientChecks(gc, op, [x1, x2], idx, [0, 1]) self.assertDeviceChecks(dc, op, [x1, x2], [0, 1]) @given(inputs=hu.tensors(n=3), **hu.gcs) @settings(deadline=10000) def test_gradient_multiple_with_indices(self, inputs, gc, dc): (x1, x2, x3) = inputs def f(inputs, outputs): for idx in [0, 1, 2]: self.assertEqual(type(inputs[idx].shape), tuple) outputs[idx].reshape(inputs[idx].shape) outputs[idx].data[...] = inputs[idx].data * 2 def grad_f(inputs, outputs): # Ordering is [inputs, outputs, grad_outputs] self.assertEqual(len(inputs), 8) self.assertEqual(len(outputs), 1) for (grad_output_idx, grad_input_idx) in [(6, 0)]: grad_output = inputs[grad_output_idx] grad_input = outputs[grad_input_idx] grad_input.reshape(grad_output.shape) grad_input.data[...] = grad_output.data * 2 op = CreatePythonOperator( f, ["x1", "x2", "x3"], ["y1", "y2", "y3"], grad_f=grad_f, grad_output_indices=[0, 2], # Receive grad outputs for y1 and y3 grad_input_indices=[0] # Produce grad inputs for x1 ) self.assertGradientChecks(gc, op, [x1, x2, x3], 0, [0, 2]) self.assertDeviceChecks(dc, op, [x1, x2, x3], [0, 1, 2])