def test_batched(self): a = graph.Placeholder(shape=(2,), batched=True) b = graph.Constant([1, 2]) c = graph.Sum(a, b) np.testing.assert_array_equal(graph.run(c, {a: np.array([[1, 2]])}), np.array([[2, 4]])) np.testing.assert_array_equal(graph.run(c, {a: np.array([[1, 2], [3, 4]])}), np.array([[2, 4], [4, 6]]))
def test_placeholder(self): a = graph.Placeholder(shape=(), batched=False) b = graph.Constant(2) c = graph.Sum(a, b) self.assertEqual(graph.run(c, {a: 3}), 5) self.assertEqual(graph.run(c, {a: 4}), 6)
def test_reduce_mean(self): x = graph.Constant([[[1], [2]], [[3], [4]], [[5], [6]]]) y1 = graph.ReduceMean(x, axis=0) y2 = graph.ReduceMean(x, axis=(1, -1)) y3 = graph.ReduceMean(x) np.testing.assert_array_equal([[3], [4]], graph.run(y1)) np.testing.assert_array_equal([1.5, 3.5, 5.5], graph.run(y2)) self.assertEqual(3.5, graph.run(y3))
def test_reduce_sum(self): x = graph.Constant([[[1], [2]], [[3], [4]], [[5], [6]]]) y1 = graph.ReduceSum(x, axis=0) y2 = graph.ReduceSum(x, axis=(1, -1)) y3 = graph.ReduceSum(x) np.testing.assert_array_equal([[9], [12]], graph.run(y1)) np.testing.assert_array_equal([3, 7, 11], graph.run(y2)) self.assertEqual(21, graph.run(y3))
def test_relu(self): x = graph.Constant([[1, 2, -3, 4], [-1, 2, -3, 0]]) y = graph.ReLU(x) y01 = graph.ReLU(x, 0.1) np.testing.assert_array_equal([[1, 2, 0, 4], [0, 2, 0, 0]], graph.run(y)) np.testing.assert_array_equal( [[1, 2, -3 * 0.1, 4], [-1 * 0.1, 2, -3 * 0.1, 0]], graph.run(y01))
def test_reduce_sum_batched(self): x_arr = np.array([[[1], [2]], [[3], [4]], [[5], [6]]]) y_arr = np.array([9, 12]) x = graph.Placeholder(shape=(3, 2, 1), batched=True) y1 = graph.ReduceSum(x, (0, 2), True) y2 = graph.ReduceSum(x, (0, 2), False) np.testing.assert_array_equal( y_arr * 3, graph.run(y1, {x: np.array([x_arr, 2 * x_arr])})) np.testing.assert_array_equal( [y_arr, 2 * y_arr], graph.run(y2, {x: np.array([x_arr, 2 * x_arr])}))
def test_relu_grad(self): x = graph.Constant([[1, 2, -3, 4], [-1, 2, -3, 0]]) y = graph.ReLU(x) y01 = graph.ReLU(x, 0.1) g = graph.Grad(y, x) g01 = graph.Grad(y01, x) np.testing.assert_array_equal([[1, 1, 0, 1], [0, 1, 0, 1]], graph.run(g)) np.testing.assert_array_equal([[1, 1, 0.1, 1], [0.1, 1, 0.1, 1]], graph.run(g01))
def test_reduce_sum_grad(self): x = graph.Constant([[[1], [2]], [[3], [4]], [[5], [6]]]) y1 = graph.ReduceSum(x, axis=0) y2 = graph.ReduceSum(x, axis=(1, -1)) y3 = graph.ReduceSum(x) g1 = graph.Grad(y1, x) g2 = graph.Grad(y2, x) g3 = graph.Grad(y3, x) np.testing.assert_array_equal(np.ones_like(x.value), graph.run(g1)) np.testing.assert_array_equal(np.ones_like(x.value), graph.run(g2)) np.testing.assert_array_equal(np.ones_like(x.value), graph.run(g3))
def test_convolution(self): x_c = graph.Constant(self.x) f_c = graph.Constant(self.filters) conv = graph.Convolution(x_c, f_c) np.testing.assert_array_equal(graph.run(conv), self.expected)
def test_convolution_with_step(self): x = graph.Constant(self.x) f = graph.Constant(self.filters) conv = graph.Convolution(x, f, step=2) np.testing.assert_array_equal(self.expected_step_2, graph.run(conv))
def run(self, inputs, expected_output, *args, tf=None, tf_session=None, **kwargs): input_dict = self.get_input_dict(inputs, expected_output) if not tf_session or not tf: loss, grads = run((self.loss, self.grad), input_dict) self._run(grads, *args, **kwargs) return loss else: if kwargs: raise NotImplementedError input_dict = { p.build_tf(tf, tf_session): v for p, v in input_dict.items() } opt_tensor = self.get_tf_opt(tf, tf_session, *args, **kwargs) loss, _ = tf_session.run(opt_tensor, input_dict) return loss
def test_reduce_sum_grad_batched(self): x_arr = np.array([[[1], [2]], [[3], [4]], [[5], [6]]]) x = graph.Placeholder(shape=(3, 2, 1), batched=True) y1 = graph.ReduceSum(x, (0, 2), True) y2 = graph.ReduceSum(x, (0, 2), False) g1 = graph.Grad(y1, x) g2 = graph.Grad(y2, x) np.testing.assert_array_equal( [np.ones_like(x_arr), np.ones_like(x_arr)], graph.run(g1, {x: np.array([x_arr, 2 * x_arr])})) np.testing.assert_array_equal( [np.ones_like(x_arr), np.ones_like(x_arr)], graph.run(g2, {x: np.array([x_arr, 2 * x_arr])}))
def test_accuracy_with_flags(self): classes = graph.Constant([1, 2, 3, 2, 0, 3]) e_classes = graph.Constant([0, 2, 3, 2, 1, 3]) flags = graph.Constant([0, 1, 1, 1, 1, 0]) acc = metrics.accuracy(e_classes, classes, flags) self.assertEqual(0.75, graph.run(acc))
def test_matmul_vec(self): x = graph.Constant([1, 2, 3]) y = graph.Constant([[1, 2], [1, 3], [2, 4]]) m = graph.Matmul(x, y) np.testing.assert_array_equal([9, 20], graph.run(m))
def test_multply(self): x1 = graph.Constant([[1], [2], [3], [4]]) x2 = graph.Constant([[1, -1], [2, -2], [3, -3], [4, -4]]) y = graph.Multiply(x1, x2) np.testing.assert_array_equal([[1, -1], [4, -4], [9, -9], [16, -16]], graph.run(y))
def test_concatenate(self): x1 = graph.Constant([[1, 2, 3], [4, 5, 6]]) x2 = graph.Constant([[7, 8], [9, 10]]) y = graph.Concatenate((x1, x2), axis=1) np.testing.assert_array_equal([[1, 2, 3, 7, 8], [4, 5, 6, 9, 10]], graph.run(y))
def test_slice_grad(self): x_arr = [[1, 2, 3], [4, 5, 6]] x = graph.Constant(x_arr) y1 = graph.Slice(x, (0, 1), (2, 2)) g1 = graph.Grad(y1, x) np.testing.assert_array_equal([[0, 1, 0], [0, 1, 0]], graph.run(g1))
def test_slice_batched(self): x_arr = np.array([[1, 2, 3], [4, 5, 6]]) x = graph.Placeholder((2, 3), True) y1 = graph.Slice(x, (0, 1), (2, 2)) np.testing.assert_array_equal([[[2], [5]], [[-2], [-5]]], graph.run( y1, {x: np.array([x_arr, -x_arr])}))
def test_softmax(self): x_arr = np.array([[1, 2, 3], [-1, -2, -3]]) x = graph.Constant(x_arr) y = graph.Softmax(x) s = np.repeat(np.sum(np.exp(x_arr - [[3], [-1]]), axis=-1), x_arr.shape[-1]).reshape(x_arr.shape) np.testing.assert_array_equal( np.exp(x_arr - [[3], [-1]]) / s, graph.run(y))
def test_slice_grad_batched(self): x_arr = np.array([[1, 2, 3], [4, 5, 6]]) x = graph.Placeholder((2, 3), True) y1 = graph.Slice(x, (0, 1), (2, 2)) g1 = graph.Grad(y1, x) np.testing.assert_array_equal( [[[0, 1, 0], [0, 1, 0]], [[0, 1, 0], [0, 1, 0]]], graph.run(g1, {x: np.array([x_arr, -x_arr])}))
def test_multply_grad(self): x1 = graph.Constant([[1], [2], [3], [4]]) x2 = graph.Constant([[1, -1], [2, -2], [3, -3], [4, -4]]) y = graph.Multiply(x1, x2) g = graph.Grad(y, (x1, x2)) g1, g2 = graph.run(g) np.testing.assert_array_equal([[0], [0], [0], [0]], g1) np.testing.assert_array_equal([[1, 1], [2, 2], [3, 3], [4, 4]], g2)
def test_concatenate_grad(self): x1 = graph.Constant([[1, 2, 3], [4, 5, 6]]) x2 = graph.Constant([[7, 8], [9, 10]]) y = graph.Concatenate((x1, x2), axis=1) g = graph.Grad(y, (x1, x2)) g1, g2 = graph.run(g) np.testing.assert_array_equal(np.ones_like(x1.value), g1) np.testing.assert_array_equal(np.ones_like(x2.value), g2)
def __call__(self, *args, tf_session=None, **kwargs): assert len(args) + len(kwargs) == len(self.inputs) assert not args or not kwargs input_dict = kwargs if kwargs else { i: v for i, v in zip(self.inputs, args) } return run(self.output, input_dict, tf_session)
def test_divide_grad(self): x1 = graph.Constant([1, 2, 3, 4]) x2 = graph.Constant([4, 3, 2, 1]) y = graph.Divide(x1, x2) g = graph.Grad(y, (x1, x2)) g1, g2 = graph.run(g) np.testing.assert_array_equal([1 / 4, 1 / 3, 1 / 2, 1], g1) np.testing.assert_array_equal([-1 / 16, -2 / 9, -3 / 4, -4], g2)
def test_matmul(self): x_arr = np.array([[1, 2], [2, 3], [3, 4]]) y_arr = np.array([[1, 2, 3, 4], [4, 5, 6, 7]]) x = graph.Constant(x_arr) y = graph.Constant(y_arr) m = graph.Matmul(x, y) np.testing.assert_array_equal(graph.run(m), np.matmul(x_arr, y_arr))
def test_convolution_batched(self): x_p = graph.Placeholder(self.x.shape, batched=True) f_c = graph.Constant(self.filters) conv = graph.Convolution(x_p, f_c) x = np.stack([self.x, 2 * self.x, 3 * self.x]) expected = np.stack( [self.expected, 2 * self.expected, 3 * self.expected]) np.testing.assert_array_equal(graph.run(conv, {x_p: x}), expected)
def test_matmul_vec_grad(self): x = graph.Constant([1, 2, 3]) y = graph.Constant([[1, 2], [1, 3], [2, 4]]) m = graph.Matmul(x, y) g = graph.Grad(m, [x, y]) g_x, g_y = graph.run(g) np.testing.assert_array_equal([3, 4, 6], g_x) np.testing.assert_array_equal([[1, 1], [2, 2], [3, 3]], g_y)
def test_grad_simple(self): a = graph.Constant(1) b = graph.Constant(2) c = graph.Constant(4) d = graph.Sum(a, b) e = graph.MultiplyByScalar(d, c) g = graph.Grad(e, [a, b, c]) self.assertSequenceEqual(graph.run(g), [4, 4, 3])
def test_convolution_grad_with_step(self): x_c = graph.Constant(self.x) f_c = graph.Constant(self.filters) conv = graph.Convolution(x_c, f_c, step=2) grad = graph.Grad(conv, [x_c, f_c]) grad_x, grad_f = graph.run(grad) np.testing.assert_array_equal(grad_x, self.grad_x_step_2) np.testing.assert_array_equal(grad_f, self.grad_f_step_2)
def test_grad(self): a = graph.Constant(1) b = graph.Constant(2) c = graph.Constant(4) d = graph.Sum(a, b) e = graph.Sum(b, c) f = graph.MultiplyByScalar(d, e) g = graph.Grad(f, [a, b, c]) self.assertSequenceEqual(graph.run(g), [6, 9, 3])