def visit(self, op, *args):
     self.computation.set_op_rank(op)
     # op.args[0] : delta
     # op.args[1] : data batch
     # op.args[2] (optional) : dbias
     # op.fprop.args[0] : data batch
     # op.fprop.args[1] : filters
     # op.fprop.conv_params : forward params
     delta = args[0]
     data = args[1]
     filters = op.fprop.args[1]
     conv_params = op.fprop.conv_params
     """
     print(delta.axes)
     print(filters.axes)
     print(data.axes)
     print(conv_params)
     """
     ngraph_update_conv = PyngConvolutionBackpropFilters(
         self.computation.lookup_cpp_op(data),
         Shape(list(filters.axes.lengths)),
         self.computation.lookup_cpp_op(delta),
         Strides([conv_params['str_h'], conv_params['str_w']]),
         Strides([conv_params['dil_h'], conv_params['dil_w']]),
         CoordinateDiff([conv_params['pad_h'], conv_params['pad_w']]),
         CoordinateDiff([conv_params['pad_h'], conv_params['pad_w']]),
         Strides([1, 1]))
     ngraph_update_conv.name = op.name.replace(
         '/', '_') + "_ConvolutionBackpropFilters"
     self.computation.register_cpp_op(op,
                                      ngraph_update_conv,
                                      set_name=False)
Example #2
0
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, cf = make_backend_call_frame(function)

    a = backend.make_primary_tensor_view(element_type, image_shape)
    b = backend.make_primary_tensor_view(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.make_primary_tensor_view(element_type, Shape([1, 1, 3,
                                                                   3]))
    result.write(util.numpy_to_c(result_arr), 0, 3 * 3 * 4)
    cf.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)