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, cf = make_backend_call_frame(function) a = backend.make_primary_tensor_view(element_type, Shape([3])) result = backend.make_primary_tensor_view(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) cf.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_broadcast(): element_type = Type.f32 A = Parameter(element_type, Shape([3])) parameter_list = [A] function = Function([Broadcast(A, Shape([3, 3]), AxisSet({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, 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_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(backend.compile(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 broadcast(node, new_shape, axis=None, name=None): # type: (Node, TensorShape, int, str) -> Node """Return node which broadcasts input node values to specified shape.""" return Broadcast(node, Shape(new_shape), get_broadcast_axes(new_shape, node.shape, axis))
def broadcast(node, new_shape, broadcast_axes, name=None): # type: (Node, TensorShape, Iterable[int], str) -> Node """Create a node which broadcasts the input node's values along specified axes to a desired shape. :param node: The node with input tensor data. :param new_shape: The new shape we want to broadcast tensor to. :param broadcast_axes: The axis positions (0-based) in the result that are being broadcast. :param name: Optional new name for output node. :return: New node with broadcast shape. """ return Broadcast(node, Shape(new_shape), AxisSet(broadcast_axes))
def make_scalar_constant(elem_type, scalar, shape=None, axis_set=None): # type: (int, float, List[int], Set[int]) -> float """Create a Constant node for scalar value.""" if shape is None: shape = Shape([]) if axis_set is None: axis_set = AxisSet(set()) scalar_shape = Shape([]) # type: List[int] constant_op = Constant(elem_type, scalar_shape, [scalar]) constant_broadcast = Broadcast(constant_op, shape, axis_set) return constant_broadcast
def broadcast(node, new_shape, axis=None, name=None): # type: (Node, TensorShape, int, str) -> Node """Return node which broadcasts input node values to specified shape. :param node: The node with input tensor data. :param new_shape: The new shape we want to broadcast tensor to. :param axis: The axis along which we perform broadcasting. :param name: Optional new name for output node. :return: New node with broadcasted shape. """ return Broadcast(node, Shape(new_shape), get_broadcast_axes(new_shape, node.shape, axis))
def broadcast_to(node, new_shape, axis=None, name=None): # type: (Node, TensorShape, int, str) -> Node """Create a node which broadcasts the input node's values to a desired shape. `broadcast_to` will attempt to automatically determine which axes need broadcasting. The optional `axis` parameter specifies the starting axis position (0-based) in the output shape from which the current shape of the tensor matches the desired new shape. e.g. current_shape: [4, 5], new_shape: [2, 3, 4, 5, 6], axis: 2 By using the `axis` parameter you can control which output axis to broadcast along. Example: >>> input_node = ng.constant([1, 2, 3]) >>> current_shape = [3] >>> new_shape = [3, 3] >>> ng.broadcast_to(input_node, new_shape, axis=1) array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) >>> ng.broadcast_to(input_node, new_shape, axis=0) array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) If the `axis` parameter is not specified, `broadcast_to` will attempt to match shapes, assuming the current shape matches the rightmost positions of the desired new shape. This behaviour is similar to NumPy's broadcasting. i.e. default `axis = len(new_shape) - len(current_shape)` :param node: The node with input tensor data. :param new_shape: The new shape we want to broadcast tensor to. :param axis: The axis along which we perform broadcasting. :param name: Optional new name for output node. :return: New node with broadcast shape. """ return Broadcast(node, Shape(new_shape), get_broadcast_axes(new_shape, node.shape, axis))
def relu(op): # type: (Node) -> Node """Relu operator.""" return Maximum(op, make_float32_constant_like(0., op)) # Flatten X1 = Reshape(Input, AxisVector([0, 1, 2]), Shape([bz, 784])) # Normalize X2 = X1 / make_float32_constant_like(255., X1) # Affine 1 W1 = Parameter(float_element_type, Shape([784, 100])) b1 = Parameter(float_element_type, Shape([100])) X3 = Dot(X2, W1) + Broadcast(b1, Shape([bz, 100]), AxisSet({0})) X4 = relu(X3) # Affine 2 W2 = Parameter(float_element_type, Shape([100, 10])) b2 = Parameter(float_element_type, Shape([10])) X5 = Dot(X4, W2) + Broadcast(b2, Shape([bz, 10]), AxisSet({0})) # Softmax Logits = X5 Exp = Exp(Logits) Max = Reduce(Exp, make_float32_constant(0., [], set()), MaxFn, AxisSet({1})) MaxBroadcast = Broadcast(Max, Shape([bz, 10]), AxisSet({1})) Softmax = Exp / MaxBroadcast # Loss