def test_replace_slice(): element_type = Type.f32 A = Parameter(element_type, Shape([6, 4])) B = Parameter(element_type, Shape([3, 2])) parameter_list = [A, B] input_arr_a = np.zeros(24, dtype=np.float32).reshape(6, 4) input_arr_b = np.ones(6, dtype=np.float32).reshape(3, 2) lower_bounds = [0, 1] upper_bounds = [3, 3] function = Function(NodeVector([ReplaceSlice(A, B, Coordinate(lower_bounds), Coordinate(upper_bounds))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, Shape([6, 4])) b = backend.create_tensor(element_type, Shape([3, 2])) result = backend.create_tensor(element_type, Shape([6, 4])) a.write(util.numpy_to_c(input_arr_a), 0, 24*4) b.write(util.numpy_to_c(input_arr_b), 0, 6*4) result_arr = np.zeros(24, dtype=np.float32).reshape(6, 4) result.write(util.numpy_to_c(result_arr), 0, 24*4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 24*4) result_arr_ref = np.copy(input_arr_a) result_arr_ref[lower_bounds[0]:upper_bounds[0], lower_bounds[1]:upper_bounds[1]] = input_arr_b assert np.allclose(result_arr, result_arr_ref) #test with strides lower_bounds = [0, 0] upper_bounds = [5, 3] strides = [2, 2] function = Function(NodeVector([ReplaceSlice(A, B, Coordinate(lower_bounds), Coordinate(upper_bounds), Strides(strides))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 24*4) result_arr_ref = np.copy(input_arr_a) result_arr_ref[::strides[0], ::strides[1]] = input_arr_b assert np.allclose(result_arr, result_arr_ref)
def test_concat(): element_type = Type.f32 A = Parameter(element_type, Shape([1, 2])) B = Parameter(element_type, Shape([1, 2])) C = Parameter(element_type, Shape([1, 2])) parameter_list = [A, B, C] axis = 0 function = Function(NodeVector([Concat(NodeVector([A, B, C]), axis)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, Shape([1, 2])) b = backend.create_tensor(element_type, Shape([1, 2])) c = backend.create_tensor(element_type, Shape([1, 2])) result = backend.create_tensor(element_type, Shape([3, 2])) a.write(util.numpy_to_c(np.array([1, 2], dtype=np.float32)), 0, 8) b.write(util.numpy_to_c(np.array([5, 6], dtype=np.float32)), 0, 8) c.write(util.numpy_to_c(np.array([7, 8], dtype=np.float32)), 0, 8) result_arr = np.zeros(6, dtype=np.float32).reshape(3, 2) result.write(util.numpy_to_c(result_arr), 0, 24) handle = backend.compile(function) handle.call([result], [a, b, c]) result.read(util.numpy_to_c(result_arr), 0, 24) a_arr = np.array([[1, 2]], dtype=np.float32) b_arr = np.array([[5, 6]], dtype=np.float32) c_arr = np.array([[7, 8]], dtype=np.float32) result_arr_ref = np.concatenate((a_arr, b_arr, c_arr), axis) assert np.allclose(result_arr, result_arr_ref)
def test_broadcast(): element_type = Type.f32 A = Parameter(element_type, Shape([3])) parameter_list = [A] function = Function( NodeVector([Broadcast(A, Shape([3, 3]), AxisSet({0}))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, Shape([3])) result = backend.create_tensor(element_type, Shape([3, 3])) a.write(util.numpy_to_c(np.array([1, 2, 3], dtype=np.float32)), 0, 12) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 36) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 0, 36) a_arr = np.array([[0], [0], [0]], dtype=np.float32) b_arr = np.array([[1, 2, 3]], dtype=np.float32) result_arr_ref = np.add(a_arr, b_arr) assert np.allclose(result_arr, result_arr_ref)
def test_reshape(): element_type = Type.f32 shape = Shape([2, 3]) A = Parameter(element_type, shape) parameter_list = [A] function = Function( NodeVector([Reshape(A, AxisVector([0, 1]), Shape([3, 2]))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([3, 2])) a.write( util.numpy_to_c(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)), 0, 24) result_arr = np.array([[0, 0], [0, 0], [0, 0]], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 24) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 0, 24) a_arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32) result_arr_ref = np.reshape(a_arr, (3, 2)) assert np.allclose(result_arr, result_arr_ref)
def test_sum(): element_type = Type.f32 shape = Shape([1, 4]) A = Parameter(element_type, shape) parameter_list = [A] function = Function(NodeVector([Sum(A, AxisSet({1}))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([1])) a.write(util.numpy_to_c(np.array([1, 2, 3, 4], dtype=np.float32)), 0, 16) result_arr = np.array([0], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 4) handle = backend.compile(function) handle.get_performance_data() handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 0, 4) a_arr = np.array([1, 2, 3, 4], dtype=np.float32) result_arr_ref = np.sum(a_arr) assert np.allclose(result_arr[0], result_arr_ref)
def unary_op_exec(op_str, input_list): """ input_list needs to have deep length of 4 """ element_type = Type.f32 shape = Shape(np.array(input_list).shape) shape_np = np.array(input_list).shape A = Parameter(element_type, shape) parameter_list = [A] function = Function(NodeVector([unary_op(op_str, A)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, shape) a.write(util.numpy_to_c(np.array(input_list, dtype=np.float32)), 0, 16) result_arr = np.zeros(shape_np, dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 16) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 0, 16) a_arr = np.array(input_list, dtype=np.float32) result_arr_ref = unary_op_ref(op_str, a_arr) assert np.allclose(result_arr, result_arr_ref)
def test_add_with_mul(): element_type = Type.f32 shape = Shape([2, 2]) A = Parameter(element_type, shape) B = Parameter(element_type, shape) C = Parameter(element_type, shape) parameter_list = [A, B, C] function = Function(NodeVector([Multiply(Add(A, B), C)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) b = backend.create_tensor(element_type, shape) c = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, shape) a.write(util.numpy_to_c(np.array([1, 2, 3, 4], dtype=np.float32)), 0, 16) b.write(util.numpy_to_c(np.array([5, 6, 7, 8], dtype=np.float32)), 0, 16) c.write(util.numpy_to_c(np.array([9, 10, 11, 12], dtype=np.float32)), 0, 16) result_arr = np.array([0, 0, 0, 0], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 16) handle = backend.compile(function) handle.call([result], [a, b, c]) result.read(util.numpy_to_c(result_arr), 0, 16) a_arr = np.array([1, 2, 3, 4], dtype=np.float32) b_arr = np.array([5, 6, 7, 8], dtype=np.float32) c_arr = np.array([9, 10, 11, 12], dtype=np.float32) result_arr_ref = (a_arr + b_arr) * c_arr assert np.allclose(result_arr, result_arr_ref)
def binary_op_comparison(op_str): element_type = Type.f32 shape = Shape([2, 2]) A = Parameter(element_type, shape) B = Parameter(element_type, shape) parameter_list = [A, B] function = Function(NodeVector([binary_op(op_str, A, B)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) b = backend.create_tensor(element_type, shape) result = backend.create_tensor(Type.boolean, shape) a.write(util.numpy_to_c(np.array([[1, 5], [3, 2]], dtype=np.float32)), 0, 16) b.write(util.numpy_to_c(np.array([[2, 4], [3, 1]], dtype=np.float32)), 0, 16) result_arr = np.array([[False, False], [False, False]], dtype=np.bool) result.write(util.numpy_to_c(result_arr), 0, 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 4) a_arr = np.array([[1, 5], [3, 2]], dtype=np.float32) b_arr = np.array([[2, 4], [3, 1]], dtype=np.float32) result_arr_ref = binary_op_ref(op_str, a_arr, b_arr) assert np.allclose(result_arr, result_arr_ref)
def test_convolution_with_filter_dilation(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) strides = [1, 1] dilation = [2, 2] function = Function( NodeVector([Convolution(A, B, Strides(strides), Strides(dilation))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 10 * 10 * 4) b.write(util.numpy_to_c(filter_arr), 0, 3 * 3 * 4) result_arr = np.zeros(36, dtype=np.float32).reshape(1, 1, 6, 6) result = backend.create_tensor(element_type, Shape([1, 1, 6, 6])) result.write(util.numpy_to_c(result_arr), 0, 6 * 6 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 6 * 6 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilation).reshape(1, 1, 6, 6) assert np.allclose(result_arr, result_arr_ref)
def test_select(): element_type = Type.f32 A = Parameter(Type.boolean, Shape([1, 2])) B = Parameter(element_type, Shape([1, 2])) C = Parameter(element_type, Shape([1, 2])) parameter_list = [A, B, C] function = Function(NodeVector([Select(A, B, C)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(Type.boolean, Shape([1, 2])) b = backend.create_tensor(element_type, Shape([1, 2])) c = backend.create_tensor(element_type, Shape([1, 2])) result = backend.create_tensor(element_type, Shape([1, 2])) a.write(util.numpy_to_c(np.array([[True, False]], dtype=np.bool)), 0, 2) b.write(util.numpy_to_c(np.array([[5, 6]], dtype=np.float32)), 0, 8) c.write(util.numpy_to_c(np.array([[7, 8]], dtype=np.float32)), 0, 8) result_arr = np.array([[0, 0]], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 8) backend.call(backend.compile(function), [result], [a, b, c]) result.read(util.numpy_to_c(result_arr), 0, 8) result_arr_ref = np.array([[5, 8]]) assert np.allclose(result_arr, result_arr_ref)
def test_reduce(): float_element_type = Type.f32 AddParam1 = Parameter(float_element_type, Shape([])) AddParam2 = Parameter(float_element_type, Shape([])) constant_op = Constant(float_element_type, Shape([]), [0.]) reduce_function = Function(NodeVector([Add(AddParam1, AddParam2)]), [AddParam1, AddParam2], 'add') A = Parameter(float_element_type, Shape([2, 2, 2])) parameter_list = [A] function = Function( NodeVector([Reduce(A, constant_op, reduce_function, AxisSet({0}))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(float_element_type, Shape([2, 2, 2])) result = backend.create_tensor(float_element_type, Shape([2, 2])) a.write(util.numpy_to_c(np.arange(8, dtype=np.float32).reshape(2, 2, 2)), 0, 32) result_arr = np.zeros((2, 2), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 16) backend.call(backend.compile(function), [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 16) a_arr = np.arange(8).reshape(2, 2, 2) result_arr_ref = np.add.reduce(a_arr) assert np.allclose(result_arr, result_arr_ref)
def binary_op_comparison(op_str): element_type = Type.f32 shape = Shape([2, 2]) A = Parameter(element_type, shape) B = Parameter(element_type, shape) parameter_list = [A, B] function = Function(NodeVector([binary_op(op_str, A, B)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) b = backend.create_tensor(element_type, shape) result = backend.create_tensor(Type.boolean, shape) a.write(util.numpy_to_c(np.array([[1, 5], [3, 2]], dtype=np.float32)), 0, 16) b.write(util.numpy_to_c(np.array([[2, 4], [3, 1]], dtype=np.float32)), 0, 16) result_arr = np.array([[False, False], [False, False]], dtype=np.bool) result.write(util.numpy_to_c(result_arr), 0, 4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 4) a_arr = np.array([[1, 5], [3, 2]], dtype=np.float32) b_arr = np.array([[2, 4], [3, 1]], dtype=np.float32) result_arr_ref = binary_op_ref(op_str, a_arr, b_arr) assert np.allclose(result_arr, result_arr_ref)
def test_convolution_with_strides(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.zeros(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr[0][0][1][1] = 1 strides = [2, 2] function = Function([Convolution(A, B, Strides(strides))], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 10 * 10 * 4) b.write(util.numpy_to_c(filter_arr), 0, 3 * 3 * 4) result_arr = np.zeros(16, dtype=np.float32).reshape(1, 1, 4, 4) result = backend.create_tensor(element_type, Shape([1, 1, 4, 4])) result.write(util.numpy_to_c(result_arr), 0, 4 * 4 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 4 * 4 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides).reshape(1, 1, 4, 4) assert np.allclose(result_arr, result_arr_ref)
def test_add_with_mul(): element_type = Type.f32 shape = Shape([2, 2]) A = Parameter(element_type, shape) B = Parameter(element_type, shape) C = Parameter(element_type, shape) parameter_list = [A, B, C] function = Function(NodeVector([Multiply(Add(A, B), C)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) b = backend.create_tensor(element_type, shape) c = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, shape) a.write(util.numpy_to_c(np.array([1, 2, 3, 4], dtype=np.float32)), 0, 16) b.write(util.numpy_to_c(np.array([5, 6, 7, 8], dtype=np.float32)), 0, 16) c.write(util.numpy_to_c(np.array([9, 10, 11, 12], dtype=np.float32)), 0, 16) result_arr = np.array([0, 0, 0, 0], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 16) backend.call(function, [result], [a, b, c]) result.read(util.numpy_to_c(result_arr), 0, 16) a_arr = np.array([1, 2, 3, 4], dtype=np.float32) b_arr = np.array([5, 6, 7, 8], dtype=np.float32) c_arr = np.array([9, 10, 11, 12], dtype=np.float32) result_arr_ref = (a_arr + b_arr) * c_arr assert np.allclose(result_arr, result_arr_ref)
def test_concat(): element_type = Type.f32 A = Parameter(element_type, Shape([1, 2])) B = Parameter(element_type, Shape([1, 2])) C = Parameter(element_type, Shape([1, 2])) parameter_list = [A, B, C] axis = 0 function = Function(NodeVector([Concat(NodeVector([A, B, C]), axis)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, Shape([1, 2])) b = backend.create_tensor(element_type, Shape([1, 2])) c = backend.create_tensor(element_type, Shape([1, 2])) result = backend.create_tensor(element_type, Shape([3, 2])) a.write(util.numpy_to_c(np.array([1, 2], dtype=np.float32)), 0, 8) b.write(util.numpy_to_c(np.array([5, 6], dtype=np.float32)), 0, 8) c.write(util.numpy_to_c(np.array([7, 8], dtype=np.float32)), 0, 8) result_arr = np.zeros(6, dtype=np.float32).reshape(3, 2) result.write(util.numpy_to_c(result_arr), 0, 24) backend.call(function, [result], [a, b, c]) result.read(util.numpy_to_c(result_arr), 0, 24) a_arr = np.array([[1, 2]], dtype=np.float32) b_arr = np.array([[5, 6]], dtype=np.float32) c_arr = np.array([[7, 8]], dtype=np.float32) result_arr_ref = np.concatenate((a_arr, b_arr, c_arr), axis) assert np.allclose(result_arr, result_arr_ref)
def test_select(): element_type = Type.f32 A = Parameter(Type.boolean, Shape([1, 2])) B = Parameter(element_type, Shape([1, 2])) C = Parameter(element_type, Shape([1, 2])) parameter_list = [A, B, C] function = Function(NodeVector([Select(A, B, C)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(Type.boolean, Shape([1, 2])) b = backend.create_tensor(element_type, Shape([1, 2])) c = backend.create_tensor(element_type, Shape([1, 2])) result = backend.create_tensor(element_type, Shape([1, 2])) a.write(util.numpy_to_c(np.array([[True, False]], dtype=np.bool)), 0, 2) b.write(util.numpy_to_c(np.array([[5, 6]], dtype=np.float32)), 0, 8) c.write(util.numpy_to_c(np.array([[7, 8]], dtype=np.float32)), 0, 8) result_arr = np.array([[0, 0]], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 8) backend.call(function, [result], [a, b, c]) result.read(util.numpy_to_c(result_arr), 0, 8) result_arr_ref = np.array([[5, 8]]) assert np.allclose(result_arr, result_arr_ref)
def test_convolution(): element_type = Type.f32 image_shape = Shape([1, 1, 16, 16]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(-128, 128, 1, dtype=np.float32).reshape(1, 1, 16, 16) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr[0][0][0][0] = -1 filter_arr[0][0][1][1] = -1 filter_arr[0][0][2][2] = -1 filter_arr[0][0][0][2] = -1 filter_arr[0][0][2][0] = -1 result_arr = np.zeros(196, dtype=np.float32).reshape(1, 1, 14, 14) function = Function(NodeVector([Convolution(A, B)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 16*16*4) b.write(util.numpy_to_c(filter_arr), 0, 3*3*4) result = backend.create_tensor(element_type, Shape([1, 1, 14, 14])) result.write(util.numpy_to_c(result_arr), 0, 14*14*4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 14*14*4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0]).reshape(1, 1, 14, 14) assert np.allclose(result_arr, result_arr_ref)
def unary_op_exec(op_str, input_list): """ input_list needs to have deep length of 4 """ element_type = Type.f32 shape = Shape(np.array(input_list).shape) shape_np = np.array(input_list).shape A = Parameter(element_type, shape) parameter_list = [A] function = Function(NodeVector([unary_op(op_str, A)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, shape) a.write(util.numpy_to_c(np.array(input_list, dtype=np.float32)), 0, 16) result_arr = np.zeros(shape_np, dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 16) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 16) a_arr = np.array(input_list, dtype=np.float32) result_arr_ref = unary_op_ref(op_str, a_arr) assert np.allclose(result_arr, result_arr_ref)
def test_reduce(): float_element_type = Type.f32 AddParam1 = Parameter(float_element_type, Shape([])) AddParam2 = Parameter(float_element_type, Shape([])) constant_op = Constant(float_element_type, Shape([]), [0.]) reduce_function = Function(NodeVector([Add(AddParam1, AddParam2)]), [AddParam1, AddParam2], 'add') A = Parameter(float_element_type, Shape([2, 2, 2])) parameter_list = [A] function = Function(NodeVector([Reduce(A, constant_op, reduce_function, AxisSet({0}))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(float_element_type, Shape([2, 2, 2])) result = backend.create_tensor(float_element_type, Shape([2, 2])) a.write(util.numpy_to_c(np.arange(8, dtype=np.float32).reshape(2, 2, 2)), 0, 32) result_arr = np.zeros((2, 2), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 16) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 16) a_arr = np.arange(8).reshape(2, 2, 2) result_arr_ref = np.add.reduce(a_arr) assert np.allclose(result_arr, result_arr_ref)
def binary_op_exec(op_str): element_type = Type.f32 shape = Shape([2, 2]) A = Parameter(element_type, shape) B = Parameter(element_type, shape) parameter_list = [A, B] function = Function(NodeVector([binary_op(op_str, A, B)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) b = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, shape) a.write(util.numpy_to_c(np.array([[1, 6], [7, 4]], dtype=np.float32)), 0, 16) b.write(util.numpy_to_c(np.array([[5, 2], [3, 8]], dtype=np.float32)), 0, 16) result_arr = np.array([[0, 0], [0, 0]], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 16) backend.call(backend.compile(function), [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 16) a_arr = np.array([[1, 6], [7, 4]], dtype=np.float32) b_arr = np.array([[5, 2], [3, 8]], dtype=np.float32) result_arr_ref = binary_op_ref(op_str, a_arr, b_arr) assert np.allclose(result_arr, result_arr_ref)
def test_convolution_with_filter_dilation(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) strides = [1, 1] dilation = [2, 2] function = Function(NodeVector([Convolution(A, B, Strides(strides), Strides(dilation))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 10*10*4) b.write(util.numpy_to_c(filter_arr), 0, 3*3*4) result_arr = np.zeros(36, dtype=np.float32).reshape(1, 1, 6, 6) result = backend.create_tensor(element_type, Shape([1, 1, 6, 6])) result.write(util.numpy_to_c(result_arr), 0, 6*6*4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 6*6*4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilation).reshape(1, 1, 6, 6) assert np.allclose(result_arr, result_arr_ref)
def test_slice(): element_type = Type.f32 shape = Shape([6, 6]) A = Parameter(element_type, shape) parameter_list = [A] input_arr = np.arange(36, dtype=np.float32).reshape(6, 6) lower_bounds = [1, 1] upper_bounds = [5, 5] function = Function(NodeVector([Slice(A, Coordinate(lower_bounds), Coordinate(upper_bounds))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([4, 4])) a.write(util.numpy_to_c(input_arr), 0, 36*4) result_arr = np.zeros(16, dtype=np.float32).reshape(4, 4) result.write(util.numpy_to_c(result_arr), 0, 16*4) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 64) result_arr_ref = input_arr[lower_bounds[0]:upper_bounds[0], lower_bounds[1]:upper_bounds[1]] assert np.allclose(result_arr, result_arr_ref) #test with strides strides = [1, 2] function = Function(NodeVector([Slice(A, Coordinate(lower_bounds), Coordinate(upper_bounds), Strides(strides))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) result = backend.create_tensor(element_type, Shape([4, 2])) result_arr = np.zeros(8, dtype=np.float32).reshape(4, 2) result.write(util.numpy_to_c(result_arr), 0, 8*4) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 32) result_arr_ref = result_arr_ref[::strides[0], ::strides[1]] assert np.allclose(result_arr, result_arr_ref)
def test_slice(): element_type = Type.f32 shape = Shape([6, 6]) A = Parameter(element_type, shape) parameter_list = [A] input_arr = np.arange(36, dtype=np.float32).reshape(6, 6) lower_bounds = [1, 1] upper_bounds = [5, 5] function = Function(NodeVector([Slice(A, Coordinate(lower_bounds), Coordinate(upper_bounds))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([4, 4])) a.write(util.numpy_to_c(input_arr), 0, 36*4) result_arr = np.zeros(16, dtype=np.float32).reshape(4, 4) result.write(util.numpy_to_c(result_arr), 0, 16*4) backend.call(backend.compile(function), [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 64) result_arr_ref = input_arr[lower_bounds[0]:upper_bounds[0], lower_bounds[1]:upper_bounds[1]] assert np.allclose(result_arr, result_arr_ref) #test with strides strides = [1, 2] function = Function(NodeVector([Slice(A, Coordinate(lower_bounds), Coordinate(upper_bounds), Strides(strides))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) result = backend.create_tensor(element_type, Shape([4, 2])) result_arr = np.zeros(8, dtype=np.float32).reshape(4, 2) result.write(util.numpy_to_c(result_arr), 0, 8*4) backend.call(backend.compile(function), [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 32) result_arr_ref = result_arr_ref[::strides[0], ::strides[1]] assert np.allclose(result_arr, result_arr_ref)
def test_convolutionBackpropData(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) output_shape = Shape([1, 1, 17, 17]) image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) window_strides = [1, 1] window_dilation = [1, 1] padding_below = [0, 0] padding_above = [0, 0] data_dilation = [2, 2] output_arr = convolution2d(image_arr[0][0], filter_arr[0][0], window_strides, window_dilation, padding_below, padding_above, data_dilation).reshape(1, 1, 17, 17) A = Parameter(element_type, filter_shape) B = Parameter(element_type, output_shape) parameter_list = [A, B] function = Function( NodeVector([ ConvolutionBackpropData(image_shape, A, B, Strides(window_strides), Strides(window_dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above), Strides(data_dilation)) ]), parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, filter_shape) b = backend.create_tensor(element_type, output_shape) a.write(util.numpy_to_c(filter_arr), 0, 3 * 3 * 4) b.write(util.numpy_to_c(output_arr), 0, 17 * 17 * 4) result_arr = np.zeros(10 * 10, dtype=np.float32).reshape(1, 1, 10, 10) result = backend.create_tensor(element_type, Shape([1, 1, 10, 10])) result.write(util.numpy_to_c(result_arr), 0, 10 * 10 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 10 * 10 * 4) result_arr_ref = np.array( [[[[22, 60, 70, 80, 90, 100, 110, 120, 130, 54.], [105, 275, 300, 325, 350, 375, 400, 425, 450, 185.], [205, 525, 550, 575, 600, 625, 650, 675, 700, 285.], [305, 775, 800, 825, 850, 875, 900, 925, 950, 385.], [405, 1025, 1050, 1075, 1100, 1125, 1150, 1175, 1200, 485.], [505, 1275, 1300, 1325, 1350, 1375, 1400, 1425, 1450, 585.], [605, 1525, 1550, 1575, 1600, 1625, 1650, 1675, 1700, 685.], [705, 1775, 1800, 1825, 1850, 1875, 1900, 1925, 1950, 785.], [805, 2025, 2050, 2075, 2100, 2125, 2150, 2175, 2200, 885.], [342, 860, 870, 880, 890, 900, 910, 920, 930, 374.]]]]) assert np.allclose(result_arr, result_arr_ref)
def test_convert(): element_type = Type.f32 shape = Shape([1, 3]) A = Parameter(element_type, shape) parameter_list = [A] # f32 to boolean function = Function(NodeVector([Convert(A, Type.boolean)]), parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(Type.boolean, shape) a.write(util.numpy_to_c(np.array([1, 5, 3], dtype=np.float32)), 0, 12) result_arr = np.array([False, False, False], dtype=np.bool) result.write(util.numpy_to_c(result_arr), 0, 3) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 0, 3) a_arr = np.array([1, 5, 3], dtype=np.float32) result_arr_ref = a_arr.astype(bool) assert np.allclose(result_arr, result_arr_ref) # f32 to i32 function = Function(NodeVector([Convert(A, Type.i32)]), parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) result = backend.create_tensor(Type.i32, shape) a.write(util.numpy_to_c(np.array([1.4, 5.5, 3.9], dtype=np.float32)), 0, 12) result_arr = np.array([0, 0, 0], dtype=np.int32) result.write(util.numpy_to_c(result_arr), 0, 12) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 0, 12) a_arr = np.array([1.4, 5.4, 3.9], dtype=np.float32) result_arr_ref = a_arr.astype(int) assert np.allclose(result_arr, result_arr_ref)
def test_convert(): element_type = Type.f32 shape = Shape([1, 3]) A = Parameter(element_type, shape) parameter_list = [A] # f32 to boolean function = Function(NodeVector([Convert(A, Type.boolean)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(Type.boolean, shape) a.write(util.numpy_to_c(np.array([1, 5, 3], dtype=np.float32)), 0, 12) result_arr = np.array([False, False, False], dtype=np.bool) result.write(util.numpy_to_c(result_arr), 0, 3) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 3) a_arr = np.array([1, 5, 3], dtype=np.float32) result_arr_ref = a_arr.astype(bool) assert np.allclose(result_arr, result_arr_ref) # f32 to i32 function = Function(NodeVector([Convert(A, Type.i32)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) result = backend.create_tensor(Type.i32, shape) a.write(util.numpy_to_c(np.array([1.4, 5.5, 3.9], dtype=np.float32)), 0, 12) result_arr = np.array([0, 0, 0], dtype=np.int32) result.write(util.numpy_to_c(result_arr), 0, 12) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 12) a_arr = np.array([1.4, 5.4, 3.9], dtype=np.float32) result_arr_ref = a_arr.astype(int) assert np.allclose(result_arr, result_arr_ref)
def test_convolutionBackpropFilters(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) output_shape = Shape([1, 1, 17, 17]) image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) window_strides = [1, 1] window_dilation = [1, 1] padding_below = [0, 0] padding_above = [0, 0] data_dilation = [2, 2] output_arr = convolution2d(image_arr[0][0], filter_arr[0][0], window_strides, window_dilation, padding_below, padding_above, data_dilation).reshape(1, 1, 17, 17) A = Parameter(element_type, image_shape) B = Parameter(element_type, output_shape) parameter_list = [A, B] function = Function( NodeVector([ ConvolutionBackpropFilters(A, filter_shape, B, Strides(window_strides), Strides(window_dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above), Strides(data_dilation)) ]), parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, output_shape) a.write(util.numpy_to_c(image_arr), 0, 10 * 10 * 4) b.write(util.numpy_to_c(output_arr), 0, 17 * 17 * 4) result_arr = np.zeros(3 * 3, dtype=np.float32).reshape(1, 1, 3, 3) result = backend.create_tensor(element_type, Shape([1, 1, 3, 3])) result.write(util.numpy_to_c(result_arr), 0, 3 * 3 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 3 * 3 * 4) result_arr_ref = np.array([[[[923832, 413952, 939870.], [425832, 190752, 432960.], [1084212, 485232, 1100250.]]]]) assert np.allclose(result_arr, result_arr_ref)
def test_convolutionBackpropData(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) output_shape = Shape([1, 1, 17, 17]) image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) window_strides = [1, 1] window_dilation = [1, 1] padding_below = [0, 0] padding_above = [0, 0] data_dilation = [2, 2] output_arr = convolution2d(image_arr[0][0], filter_arr[0][0], window_strides, window_dilation, padding_below, padding_above, data_dilation).reshape(1, 1, 17, 17) A = Parameter(element_type, filter_shape) B = Parameter(element_type, output_shape) parameter_list = [A, B] function = Function(NodeVector([ConvolutionBackpropData(image_shape, A, B, Strides(window_strides), Strides(window_dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above), Strides(data_dilation))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, filter_shape) b = backend.create_tensor(element_type, output_shape) a.write(util.numpy_to_c(filter_arr), 0, 3*3*4) b.write(util.numpy_to_c(output_arr), 0, 17*17*4) result_arr = np.zeros(10*10, dtype=np.float32).reshape(1, 1, 10, 10) result = backend.create_tensor(element_type, Shape([1, 1, 10, 10])) result.write(util.numpy_to_c(result_arr), 0, 10*10*4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 10*10*4) result_arr_ref = np.array( [[[[ 22, 60, 70, 80, 90, 100, 110, 120, 130, 54.], [ 105, 275, 300, 325, 350, 375, 400, 425, 450, 185.], [ 205, 525, 550, 575, 600, 625, 650, 675, 700, 285.], [ 305, 775, 800, 825, 850, 875, 900, 925, 950, 385.], [ 405, 1025, 1050, 1075, 1100, 1125, 1150, 1175, 1200, 485.], [ 505, 1275, 1300, 1325, 1350, 1375, 1400, 1425, 1450, 585.], [ 605, 1525, 1550, 1575, 1600, 1625, 1650, 1675, 1700, 685.], [ 705, 1775, 1800, 1825, 1850, 1875, 1900, 1925, 1950, 785.], [ 805, 2025, 2050, 2075, 2100, 2125, 2150, 2175, 2200, 885.], [ 342, 860, 870, 880, 890, 900, 910, 920, 930, 374.]]]]) assert np.allclose(result_arr, result_arr_ref)
def test_convolutionBackpropFilters(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) output_shape = Shape([1, 1, 17, 17]) image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) window_strides = [1, 1] window_dilation = [1, 1] padding_below = [0, 0] padding_above = [0, 0] data_dilation = [2, 2] output_arr = convolution2d(image_arr[0][0], filter_arr[0][0], window_strides, window_dilation, padding_below, padding_above, data_dilation).reshape(1, 1, 17, 17) A = Parameter(element_type, image_shape) B = Parameter(element_type, output_shape) parameter_list = [A, B] function = Function(NodeVector([ConvolutionBackpropFilters(A, filter_shape, B, Strides(window_strides), Strides(window_dilation), CoordinateDiff(padding_below),CoordinateDiff(padding_above), Strides(data_dilation))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, output_shape) a.write(util.numpy_to_c(image_arr), 0, 10*10*4) b.write(util.numpy_to_c(output_arr), 0, 17*17*4) result_arr = np.zeros(3*3, dtype=np.float32).reshape(1, 1, 3, 3) result = backend.create_tensor(element_type, Shape([1, 1, 3, 3])) result.write(util.numpy_to_c(result_arr), 0, 3*3*4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 3*3*4) result_arr_ref = np.array( [[[[ 923832, 413952, 939870.], [ 425832, 190752, 432960.], [1084212, 485232, 1100250.]]]]) assert np.allclose(result_arr, result_arr_ref)
def test_constant(): element_type = Type.f32 parameter_list = [] function = Function(NodeVector([Constant(element_type, Shape([3, 3]), list(range(9)))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) result = backend.create_tensor(element_type, Shape([3, 3])) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 36) backend.call(function, [result], []) result.read(util.numpy_to_c(result_arr), 0, 36) result_arr_ref = np.arange(9).reshape(3, 3) assert np.allclose(result_arr, result_arr_ref)
def test_constant(): element_type = Type.f32 parameter_list = [] function = Function(NodeVector([Constant(element_type, Shape([3, 3]), list(range(9)))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) result = backend.create_tensor(element_type, Shape([3, 3])) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 36) backend.call(backend.compile(function), [result], []) result.read(util.numpy_to_c(result_arr), 0, 36) result_arr_ref = np.arange(9).reshape(3, 3) assert np.allclose(result_arr, result_arr_ref)
def test_convolution_simple(): element_type = Type.f32 image_shape = Shape([1, 1, 16, 16]) filter_shape = Shape([1, 1, 3, 3]) data = Parameter(element_type, image_shape) filters = Parameter(element_type, filter_shape) parameter_list = [data, filters] image_arr = np.arange(-128, 128, 1, dtype=np.float32).reshape(1, 1, 16, 16) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr[0][0][0][0] = -1 filter_arr[0][0][1][1] = -1 filter_arr[0][0][2][2] = -1 filter_arr[0][0][0][2] = -1 filter_arr[0][0][2][0] = -1 result_arr = np.zeros(196, dtype=np.float32).reshape(1, 1, 14, 14) strides = [1, 1] pads_begin = [0, 0] pads_end = [0, 0] dilations = [1, 1] model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations) function = Function([model], parameter_list, "test") backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 16 * 16 * 4) b.write(util.numpy_to_c(filter_arr), 3 * 3 * 4) result = backend.create_tensor(element_type, Shape([1, 1, 14, 14])) result.write(util.numpy_to_c(result_arr), 14 * 14 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 14 * 14 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0]).reshape(1, 1, 14, 14) assert np.allclose(result_arr, result_arr_ref)
def test_convolution_with_data_dilation(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) strides = [1, 1] dilation = [1, 1] padding_below = [0, 0] padding_above = [0, 0] data_dilation = [2, 2] function = Function( NodeVector([ Convolution(A, B, Strides(strides), Strides(dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above), Strides(data_dilation)) ]), parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 10 * 10 * 4) b.write(util.numpy_to_c(filter_arr), 0, 3 * 3 * 4) result_arr = np.zeros(17 * 17, dtype=np.float32).reshape(1, 1, 17, 17) result = backend.create_tensor(element_type, Shape([1, 1, 17, 17])) result.write(util.numpy_to_c(result_arr), 0, 17 * 17 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 17 * 17 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilation, padding_below, padding_above, data_dilation).reshape(1, 1, 17, 17) assert np.allclose(result_arr, result_arr_ref)
def test_constant(): element_type = Type.f32 parameter_list = [] function = Function( [Constant(element_type, Shape([3, 3]), list(range(9)))], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) result = backend.create_tensor(element_type, Shape([3, 3])) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 36) handle = backend.compile(function) handle.call([result], []) result.read(util.numpy_to_c(result_arr), 36) result_arr_ref = np.arange(9).reshape(3, 3) assert np.allclose(result_arr, result_arr_ref)
def test_not(): element_type = Type.boolean shape = Shape([2]) A = Parameter(element_type, shape) parameter_list = [A] function = Function(NodeVector([Not(A)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(Type.boolean, shape) a.write(util.numpy_to_c(np.array([True, False], dtype=np.bool)), 0, 2) result_arr = np.array([False, False], dtype=np.bool) result.write(util.numpy_to_c(result_arr), 0, 2) backend.call(backend.compile(function), [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 2) a_arr = np.array([True, False], dtype=np.bool) result_arr_ref = np.logical_not(a_arr) assert np.allclose(result_arr, result_arr_ref)
def test_not(): element_type = Type.boolean shape = Shape([2]) A = Parameter(element_type, shape) parameter_list = [A] function = Function(NodeVector([Not(A)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(Type.boolean, shape) a.write(util.numpy_to_c(np.array([True, False], dtype=np.bool)), 0, 2) result_arr = np.array([False, False], dtype=np.bool) result.write(util.numpy_to_c(result_arr), 0, 2) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 2) a_arr = np.array([True, False], dtype=np.bool) result_arr_ref = np.logical_not(a_arr) assert np.allclose(result_arr, result_arr_ref)
def test_onehot(): element_type = Type.f32 A = Parameter(element_type, Shape([3])) parameter_list = [A] function = Function(NodeVector([OneHot(A, Shape([3, 3]), 0)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, Shape([3])) result = backend.create_tensor(element_type, Shape([3, 3])) a.write(util.numpy_to_c(np.array([1, 0, 2], dtype=np.float32)), 0, 12) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 36) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 36) a_arr = np.array([1, 0, 2]) result_arr_ref = np.eye(3)[a_arr] assert np.allclose(result_arr, result_arr_ref)
def test_onehot(): element_type = Type.f32 A = Parameter(element_type, Shape([3])) parameter_list = [A] function = Function(NodeVector([OneHot(A, Shape([3, 3]), 0)]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, Shape([3])) result = backend.create_tensor(element_type, Shape([3, 3])) a.write(util.numpy_to_c(np.array([1, 0, 2], dtype=np.float32)), 0, 12) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 36) backend.call(backend.compile(function), [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 36) a_arr = np.array([1, 0, 2]) result_arr_ref = np.eye(3)[a_arr] assert np.allclose(result_arr, result_arr_ref)
def test_convolution_with_padding(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) data = Parameter(element_type, image_shape) filters = Parameter(element_type, filter_shape) parameter_list = [data, filters] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.zeros(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr[0][0][1][1] = 1 strides = [1, 1] dilations = [2, 2] pads_begin = [0, 0] pads_end = [0, 0] model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations) function = Function([model], parameter_list, "test") backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 10 * 10 * 4) b.write(util.numpy_to_c(filter_arr), 3 * 3 * 4) result_arr = np.zeros(36, dtype=np.float32).reshape(1, 1, 6, 6) result = backend.create_tensor(element_type, Shape([1, 1, 6, 6])) result.write(util.numpy_to_c(result_arr), 6 * 6 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 6 * 6 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilations, pads_begin, pads_end).reshape(1, 1, 6, 6) assert np.allclose(result_arr, result_arr_ref)
def test_sum(): element_type = Type.f32 shape = Shape([1, 4]) A = Parameter(element_type, shape) parameter_list = [A] function = Function(NodeVector([Sum(A, AxisSet({1}))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([1])) a.write(util.numpy_to_c(np.array([1, 2, 3, 4], dtype=np.float32)), 0, 16) result_arr = np.array([0], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 4) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 4) a_arr = np.array([1, 2, 3, 4], dtype=np.float32) result_arr_ref = np.sum(a_arr) assert np.allclose(result_arr[0], result_arr_ref)
def test_broadcast(): element_type = Type.f32 A = Parameter(element_type, Shape([3])) parameter_list = [A] function = Function(NodeVector([Broadcast(A, Shape([3, 3]), AxisSet({0}))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, Shape([3])) result = backend.create_tensor(element_type, Shape([3, 3])) a.write(util.numpy_to_c(np.array([1, 2, 3], dtype=np.float32)), 0, 12) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 36) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 36) a_arr = np.array([[0], [0], [0]], dtype=np.float32) b_arr = np.array([[1, 2, 3]], dtype=np.float32) result_arr_ref = np.add(a_arr, b_arr) assert np.allclose(result_arr, result_arr_ref)
def test_onehot(): element_type = Type.i32 A = Parameter(element_type, Shape([3])) parameter_list = [A] function = Function([OneHot(A, Shape([3, 3]), 0)], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, Shape([3])) result = backend.create_tensor(element_type, Shape([3, 3])) a.write(util.numpy_to_c(np.array([1, 0, 2], dtype=np.int32)), 12) result_arr = np.zeros((3, 3), dtype=np.int32) result.write(util.numpy_to_c(result_arr), 36) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 36) a_arr = np.array([1, 0, 2]) result_arr_ref = np.eye(3)[a_arr] assert np.allclose(result_arr, result_arr_ref)
def test_reshape(): element_type = Type.f32 shape = Shape([2, 3]) A = Parameter(element_type, shape) parameter_list = [A] function = Function(NodeVector([Reshape(A, AxisVector([0, 1]), Shape([3, 2]))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([3, 2])) a.write(util.numpy_to_c(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)), 0, 24) result_arr = np.array([[0, 0], [0, 0], [0, 0]], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 0, 24) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 24) a_arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32) result_arr_ref = np.reshape(a_arr, (3, 2)) assert np.allclose(result_arr, result_arr_ref)
def test_not(): element_type = Type.boolean shape = Shape([2]) A = Parameter(element_type, shape) parameter_list = [A] function = Function([Not(A)], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(Type.boolean, shape) a.write(util.numpy_to_c(np.array([True, False], dtype=np.bool)), 2) result_arr = np.array([False, False], dtype=np.bool) result.write(util.numpy_to_c(result_arr), 2) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 2) a_arr = np.array([True, False], dtype=np.bool) result_arr_ref = np.logical_not(a_arr) assert np.allclose(result_arr, result_arr_ref)
def test_convolution(): element_type = Type.f32 image_shape = Shape([1, 1, 16, 16]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(-128, 128, 1, dtype=np.float32).reshape(1, 1, 16, 16) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr[0][0][0][0] = -1 filter_arr[0][0][1][1] = -1 filter_arr[0][0][2][2] = -1 filter_arr[0][0][0][2] = -1 filter_arr[0][0][2][0] = -1 result_arr = np.zeros(196, dtype=np.float32).reshape(1, 1, 14, 14) function = Function(NodeVector([Convolution(A, B)]), parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 16 * 16 * 4) b.write(util.numpy_to_c(filter_arr), 0, 3 * 3 * 4) result = backend.create_tensor(element_type, Shape([1, 1, 14, 14])) result.write(util.numpy_to_c(result_arr), 0, 14 * 14 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 14 * 14 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0]).reshape(1, 1, 14, 14) assert np.allclose(result_arr, result_arr_ref)
def test_sum(): element_type = Type.f32 shape = Shape([1, 4]) A = Parameter(element_type, shape) parameter_list = [A] function = Function([Sum(A, AxisSet({1}))], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([1])) a.write(util.numpy_to_c(np.array([1, 2, 3, 4], dtype=np.float32)), 16) result_arr = np.array([0], dtype=np.float32) result.write(util.numpy_to_c(result_arr), 4) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 4) a_arr = np.array([1, 2, 3, 4], dtype=np.float32) result_arr_ref = np.sum(a_arr) assert np.allclose(result_arr[0], result_arr_ref)
def test_broadcast(): element_type = Type.f32 A = Parameter(element_type, Shape([3])) parameter_list = [A] function = Function([ng.broadcast(A, [3, 3])], parameter_list, "test") backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, Shape([3])) result = backend.create_tensor(element_type, Shape([3, 3])) a.write(util.numpy_to_c(np.array([1, 2, 3], dtype=np.float32)), 12) result_arr = np.zeros((3, 3), dtype=np.float32) result.write(util.numpy_to_c(result_arr), 36) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 36) a_arr = np.array([[0], [0], [0]], dtype=np.float32) b_arr = np.array([[1, 2, 3]], dtype=np.float32) result_arr_ref = np.add(a_arr, b_arr) assert np.allclose(result_arr, result_arr_ref)
def test_max_pool(): #test 1d element_type = Type.f32 shape = Shape([1, 1, 10]) A = Parameter(element_type, shape) parameter_list = [A] input_arr = np.arange(10, dtype=np.float32).reshape(1, 1, 10) window_shape = [3] function = Function([MaxPool(A, Shape(window_shape))], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([1, 1, 8])) a.write(util.numpy_to_c(input_arr), 10 * 4) result_arr = np.zeros(8, dtype=np.float32).reshape(1, 1, 8) result.write(util.numpy_to_c(result_arr), 8 * 4) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 32) result_arr_ref = (np.arange(8) + 2).reshape(1, 1, 8) assert np.allclose(result_arr, result_arr_ref) #test 1d with strides strides = [2] function = Function([MaxPool(A, Shape(window_shape), Strides(strides))], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) size = 4 result = backend.create_tensor(element_type, Shape([1, 1, size])) result_arr = np.zeros(size, dtype=np.float32).reshape(1, 1, size) result.write(util.numpy_to_c(result_arr), size * 4) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), size * 4) result_arr_ref = ((np.arange(size) + 1) * 2).reshape(1, 1, size) assert np.allclose(result_arr, result_arr_ref) #test 2d element_type = Type.f32 shape = Shape([1, 1, 10, 10]) A = Parameter(element_type, shape) parameter_list = [A] input_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) window_shape = [3, 3] function = Function([MaxPool(A, Shape(window_shape))], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([1, 1, 8, 8])) a.write(util.numpy_to_c(input_arr), 10 * 10 * 4) result_arr = np.zeros(64, dtype=np.float32).reshape(1, 1, 8, 8) result.write(util.numpy_to_c(result_arr), 8 * 8 * 4) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), 8 * 8 * 4) result_arr_ref = ((np.arange(100).reshape(10, 10))[2:, 2:]).reshape(1, 1, 8, 8) assert np.allclose(result_arr, result_arr_ref) #test 2d with strides strides = [2, 2] function = Function([MaxPool(A, Shape(window_shape), Strides(strides))], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) size = 4 result = backend.create_tensor(element_type, Shape([1, 1, size, size])) result_arr = np.zeros(size * size, dtype=np.float32).reshape(1, 1, size, size) result.write(util.numpy_to_c(result_arr), size * size * 4) handle = backend.compile(function) handle.call([result], [a]) result.read(util.numpy_to_c(result_arr), size * size * 4) result_arr_ref = ((np.arange(100).reshape(10, 10))[2::2, 2::2]).reshape( 1, 1, size, size) assert np.allclose(result_arr, result_arr_ref)
def test_convolution_with_padding(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.zeros(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr[0][0][1][1] = 1 strides = [1, 1] dilation = [2, 2] padding_below = [0, 0] padding_above = [0, 0] function = Function(NodeVector([Convolution(A, B, Strides(strides), Strides(dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 10*10*4) b.write(util.numpy_to_c(filter_arr), 0, 3*3*4) result_arr = np.zeros(36, dtype=np.float32).reshape(1, 1, 6, 6) result = backend.create_tensor(element_type, Shape([1, 1, 6, 6])) result.write(util.numpy_to_c(result_arr), 0, 6*6*4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 6*6*4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilation, padding_below, padding_above).reshape(1, 1, 6, 6) assert np.allclose(result_arr, result_arr_ref) # test with non-zero padding element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = (np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3)) * -1 filter_arr[0][0][1][1] = 1 strides = [1, 1] dilation = [2, 2] padding_below = [2, 1] padding_above = [1, 2] function = Function(NodeVector([Convolution(A, B, Strides(strides), Strides(dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 0, 10*10*4) b.write(util.numpy_to_c(filter_arr), 0, 3*3*4) result_arr = np.zeros(81, dtype=np.float32).reshape(1, 1, 9, 9) result = backend.create_tensor(element_type, Shape([1, 1, 9, 9])) result.write(util.numpy_to_c(result_arr), 0, 9*9*4) backend.call(function, [result], [a, b]) result.read(util.numpy_to_c(result_arr), 0, 9*9*4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilation, padding_below, padding_above).reshape(1, 1, 9, 9) assert np.allclose(result_arr, result_arr_ref)
def test_convolution_with_padding(): element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = np.zeros(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr[0][0][1][1] = 1 strides = [1, 1] dilation = [2, 2] padding_below = [0, 0] padding_above = [0, 0] function = Function([ Convolution(A, B, Strides(strides), Strides(dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above)) ], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 10 * 10 * 4) b.write(util.numpy_to_c(filter_arr), 3 * 3 * 4) result_arr = np.zeros(36, dtype=np.float32).reshape(1, 1, 6, 6) result = backend.create_tensor(element_type, Shape([1, 1, 6, 6])) result.write(util.numpy_to_c(result_arr), 6 * 6 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 6 * 6 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilation, padding_below, padding_above).reshape(1, 1, 6, 6) assert np.allclose(result_arr, result_arr_ref) # test with non-zero padding element_type = Type.f32 image_shape = Shape([1, 1, 10, 10]) filter_shape = Shape([1, 1, 3, 3]) A = Parameter(element_type, image_shape) B = Parameter(element_type, filter_shape) parameter_list = [A, B] image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) filter_arr = (np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3)) * -1 filter_arr[0][0][1][1] = 1 strides = [1, 1] dilation = [2, 2] padding_below = [2, 1] padding_above = [1, 2] function = Function([ Convolution(A, B, Strides(strides), Strides(dilation), CoordinateDiff(padding_below), CoordinateDiff(padding_above)) ], parameter_list, 'test') backend = Backend.create(test.BACKEND_NAME) a = backend.create_tensor(element_type, image_shape) b = backend.create_tensor(element_type, filter_shape) a.write(util.numpy_to_c(image_arr), 10 * 10 * 4) b.write(util.numpy_to_c(filter_arr), 3 * 3 * 4) result_arr = np.zeros(81, dtype=np.float32).reshape(1, 1, 9, 9) result = backend.create_tensor(element_type, Shape([1, 1, 9, 9])) result.write(util.numpy_to_c(result_arr), 9 * 9 * 4) handle = backend.compile(function) handle.call([result], [a, b]) result.read(util.numpy_to_c(result_arr), 9 * 9 * 4) result_arr_ref = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilation, padding_below, padding_above).reshape(1, 1, 9, 9) assert np.allclose(result_arr, result_arr_ref)
def __init__(self, backend_name): # type: (str) -> None self.backend_name = backend_name self.backend = Backend.create(backend_name)
def test_max_pool(): #test 1d element_type = Type.f32 shape = Shape([1, 1, 10]) A = Parameter(element_type, shape) parameter_list = [A] input_arr = np.arange(10, dtype=np.float32).reshape(1, 1, 10) window_shape = [3] function = Function(NodeVector([MaxPool(A, Shape(window_shape))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([1, 1, 8])) a.write(util.numpy_to_c(input_arr), 0, 10*4) result_arr = np.zeros(8, dtype=np.float32).reshape(1, 1, 8) result.write(util.numpy_to_c(result_arr), 0, 8*4) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 32) result_arr_ref = (np.arange(8) + 2).reshape(1, 1, 8) assert np.allclose(result_arr, result_arr_ref) #test 1d with strides strides = [2] function = Function(NodeVector([MaxPool(A, Shape(window_shape), Strides(strides))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) size = 4 result = backend.create_tensor(element_type, Shape([1, 1, size])) result_arr = np.zeros(size, dtype=np.float32).reshape(1, 1, size) result.write(util.numpy_to_c(result_arr), 0, size*4) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, size*4) result_arr_ref = ((np.arange(size) + 1) * 2).reshape(1, 1, size) assert np.allclose(result_arr, result_arr_ref) #test 2d element_type = Type.f32 shape = Shape([1, 1, 10, 10]) A = Parameter(element_type, shape) parameter_list = [A] input_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) window_shape = [3, 3] function = Function(NodeVector([MaxPool(A, Shape(window_shape))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) a = backend.create_tensor(element_type, shape) result = backend.create_tensor(element_type, Shape([1, 1, 8, 8])) a.write(util.numpy_to_c(input_arr), 0, 10*10*4) result_arr = np.zeros(64, dtype=np.float32).reshape(1, 1, 8, 8) result.write(util.numpy_to_c(result_arr), 0, 8*8*4) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, 8*8*4) result_arr_ref = ((np.arange(100).reshape(10, 10))[2:, 2:]).reshape(1, 1, 8, 8) assert np.allclose(result_arr, result_arr_ref) #test 2d with strides strides = [2, 2] function = Function(NodeVector([MaxPool(A, Shape(window_shape), Strides(strides))]), parameter_list, 'test') backend = Backend.create(pytest.config.getoption('backend')) size = 4 result = backend.create_tensor(element_type, Shape([1, 1, size, size])) result_arr = np.zeros(size*size, dtype=np.float32).reshape(1, 1, size, size) result.write(util.numpy_to_c(result_arr), 0, size*size*4) backend.call(function, [result], [a]) result.read(util.numpy_to_c(result_arr), 0, size*size*4) result_arr_ref = ((np.arange(100).reshape(10, 10))[2::2, 2::2]).reshape(1, 1, size, size) assert np.allclose(result_arr, result_arr_ref)