Esempio n. 1
0
def test_cropping_3d():
    num_samples = 2
    stack_size = 2
    input_len_dim1 = 8
    input_len_dim2 = 8
    input_len_dim3 = 8
    cropping = ((2, 2), (3, 3), (2, 3))

    for data_format in ['channels_last', 'channels_first']:
        if data_format == 'channels_first':
            inputs = np.random.rand(num_samples, stack_size,
                                    input_len_dim1, input_len_dim2, input_len_dim3)
        else:
            inputs = np.random.rand(num_samples,
                                    input_len_dim1, input_len_dim2,
                                    input_len_dim3, stack_size)
        # basic test
        layer_test(convolutional.Cropping3D,
                   kwargs={'cropping': cropping,
                           'data_format': data_format},
                   input_shape=inputs.shape)
        # correctness test
        layer = convolutional.Cropping3D(cropping=cropping,
                                         data_format=data_format)
        layer.build(inputs.shape)
        outputs = layer(K.variable(inputs))
        np_output = K.eval(outputs)
        # compare with numpy
        if data_format == 'channels_first':
            expected_out = inputs[:, :, cropping[0][0]: -cropping[0][1], cropping[1][0]: -cropping[1][1], cropping[2][0]: -cropping[2][1]]
        else:
            expected_out = inputs[:, cropping[0][0]: -cropping[0][1], cropping[1][0]: -cropping[1][1], cropping[2][0]: -cropping[2][1], :]
        assert_allclose(np_output, expected_out)

    for data_format in ['channels_last', 'channels_first']:
        if data_format == 'channels_first':
            inputs = np.random.rand(num_samples, stack_size,
                                    input_len_dim1, input_len_dim2, input_len_dim3)
        else:
            inputs = np.random.rand(num_samples,
                                    input_len_dim1, input_len_dim2,
                                    input_len_dim3, stack_size)
        # another correctness test (no cropping)
        cropping = ((0, 0), (0, 0), (0, 0))
        layer = convolutional.Cropping3D(cropping=cropping,
                                         data_format=data_format)
        layer.build(inputs.shape)
        outputs = layer(K.variable(inputs))
        np_output = K.eval(outputs)
        # compare with input
        assert_allclose(np_output, inputs)

    # Test invalid use cases
    with pytest.raises(ValueError):
        layer = convolutional.Cropping3D(cropping=((1, 1),))
    with pytest.raises(ValueError):
        layer = convolutional.Cropping3D(cropping=lambda x: x)
Esempio n. 2
0
def test_cropping_3d():
    nb_samples = 2
    stack_size = 2
    input_len_dim1 = 8
    input_len_dim2 = 8
    input_len_dim3 = 8
    cropping = ((2, 2), (3, 3), (2, 3))
    dim_ordering = K.image_dim_ordering()

    if dim_ordering == 'th':
        input = np.random.rand(nb_samples, stack_size,
                               input_len_dim1, input_len_dim2, input_len_dim3)
    else:
        input = np.random.rand(nb_samples,
                               input_len_dim1, input_len_dim2,
                               input_len_dim3, stack_size)
    # basic test
    layer_test(convolutional.Cropping3D,
               kwargs={'cropping': cropping,
                       'dim_ordering': dim_ordering},
               input_shape=input.shape)
    # correctness test
    layer = convolutional.Cropping3D(cropping=cropping,
                                     dim_ordering=dim_ordering)
    layer.build(input.shape)
    output = layer(K.variable(input))
    np_output = K.eval(output)
    # compare with numpy
    if dim_ordering == 'th':
        expected_out = input[:,
                             :,
                             cropping[0][0]: -cropping[0][1],
                             cropping[1][0]: -cropping[1][1],
                             cropping[2][0]: -cropping[2][1]]
    else:
        expected_out = input[:,
                             cropping[0][0]: -cropping[0][1],
                             cropping[1][0]: -cropping[1][1],
                             cropping[2][0]: -cropping[2][1],
                             :]
    assert_allclose(np_output, expected_out)
    # another correctness test (no cropping)
    cropping = ((0, 0), (0, 0), (0, 0))
    layer = convolutional.Cropping3D(cropping=cropping,
                                     dim_ordering=dim_ordering)
    layer.build(input.shape)
    output = layer(K.variable(input))
    np_output = K.eval(output)
    # compare with input
    assert_allclose(np_output, input)