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])
def test_exception_builder(self): op = CreatePythonOperator(MainOpFunctionThatThrowsCustomErrorInBuilder, [], []) with six.assertRaisesRegex( self, CustomError, "This is an intentional exception in builder."): workspace.RunOperatorOnce(op)
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_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)
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)
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)
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])
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)
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])
def test_exception(self): op = CreatePythonOperator(MainOpFunctionThatThrowsRuntimeError, [], []) with self.assertRaisesRegexp( RuntimeError, "This is an intentional exception." ): workspace.RunOperatorOnce(op)
def test_forward_and_gradient(self): N = 64 Ncls = 2 Y = np.random.randn(N, 4 * Ncls).astype(np.float32) Y_hat = np.random.randn(N, 4 * Ncls).astype(np.float32) U = np.random.randn(N, 10 * Ncls).astype(np.float32) print(np.prod(Y.shape)) print(np.prod(U.shape)) inside_weights = np.random.randn(N, 4 * Ncls).astype(np.float32) inside_weights[inside_weights < 0] = 0 #outside_weights = np.ones((N, 4 * Ncls)).astype(np.float32) outside_weights_ind = np.random.randint(0, Ncls, N) outside_weights = np.zeros((N, 4 * Ncls)).astype(np.float32) for i in range(N): ind = 4 * outside_weights_ind[i] outside_weights[i, ind:ind + 4] = 1 scale = np.random.random() beta = np.random.random() bbox_inw = outside_weights * (Y - Y_hat) #op = CreatePythonOperator( # CovLossOp().forward, ["x1", "x2", "x3"], ["y1"], # grad_f=CovLossOp().backward, # grad_input_indices=[0, 1] # ) #op = CreatePythonOperator( # UpperTriangularOp().forward, ["x1"], ["y1"], # grad_f=UpperTriangularOp().backward, # #grad_input_indices=[0, 1] # ) op = CreatePythonOperator( LogDetOp().forward, ["x1"], ["y1"], grad_f=LogDetOp().backward, #grad_input_indices=[0, 1] ) #op = CreatePythonOperator( # SimpleOp().forward, ["x1"], ["y1"], # grad_f=SimpleOp().backward, # #grad_input_indices=[0, 1] # ) 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, [bbox_inw, U, outside_weights], 0, [0] #) U = U.reshape((N, Ncls, 10)) U_reshape = np.zeros((N, Ncls, 4, 4), dtype=U.dtype) U_reshape[:, :, 0, 0] = np.exp(U[:, :, 0]) U_reshape[:, :, 1, 1] = np.exp(U[:, :, 4]) U_reshape[:, :, 2, 2] = np.exp(U[:, :, 7]) U_reshape[:, :, 3, 3] = np.exp(U[:, :, 9]) U_reshape[:, :, 0, 1:] = U[:, :, 1:4] U_reshape[:, :, 1, 2:] = U[:, :, 5:7] U_reshape[:, :, 2, 3] = U[:, :, 8] res, grad, grad_estimated = gc.CheckSimple(op, [U_reshape], 0, [0]) #res, grad, grad_estimated = gc.CheckSimple( # op, [U], 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)
def test_exception(self): op = CreatePythonOperator(MainOpFunctionThatThrowsRuntimeError, [], []) with self.assertRaises(RuntimeError): workspace.RunOperatorOnce(op)