示例#1
0
 def test_deconvolution_repr(self):
     layer = layers.Deconvolution((3, 3, 10), name='deconv')
     self.assertEqual(
         str(layer),
         (
             "Deconvolution((3, 3, 10), padding='VALID', stride=(1, 1), "
             "weight=HeNormal(gain=2), bias=Constant(0), name='deconv')"
         )
     )
示例#2
0
    def test_deconvolution(self):
        network = layers.join(
            layers.Input((10, 10, 3)),
            layers.Convolution((3, 3, 7)),
            layers.Deconvolution((3, 3, 4)),
        )

        shapes = [layer.output_shape for layer in network.layers]
        self.assertSequenceEqual(shapes, [(10, 10, 3), (8, 8, 7), (10, 10, 4)])

        input_value = asfloat(np.random.random((1, 10, 10, 3)))
        actual_output = self.eval(network.output(input_value))

        self.assertEqual(actual_output.shape, (1, 10, 10, 4))
示例#3
0
    def test_deconvolution_for_random_cases(self):
        # A few random cases will check if output shape computed from
        # the network is the same as the shape that we get after we
        # propagated input through the network.
        for test_id in range(30):
            width = random.randint(7, 20)
            height = random.randint(7, 20)

            fh = random.randint(1, 7)
            fw = random.randint(1, 7)

            pad = random.choice([
                'valid',
                'same',
                random.randint(0, 10),
                (
                    random.randint(0, 10),
                    random.randint(0, 10),
                ),
            ])
            stride = random.choice([
                random.randint(1, 4),
                (
                    random.randint(1, 4),
                    random.randint(1, 4),
                ),
            ])

            print('\n------------')
            print("Test case #{}".format(test_id))
            print('------------')
            print("Image shape: {}x{}".format(height, width))
            print("Filter shape: {}x{}".format(fh, fw))
            print("Padding: {}".format(pad))
            print("Stride: {}".format(stride))

            network = layers.join(
                layers.Input((height, width, 1)),
                layers.Convolution((fh, fw, 2), padding=pad, stride=stride),
                layers.Deconvolution((fh, fw, 1), padding=pad, stride=stride),
            )

            input_value = asfloat(np.random.random((1, height, width, 1)))
            actual_output = self.eval(network.output(input_value))
            self.assertEqual(actual_output.shape[1:], network.output_shape)
示例#4
0
    def test_deconv_unknown_input_width_and_height(self):
        network = layers.join(
            layers.Input((None, None, 3)),
            layers.Convolution((3, 3, 7)),
            layers.Deconvolution((3, 3, 4)),
        )

        shapes = [layer.output_shape for layer in network.layers]
        self.assertSequenceEqual(shapes, [(None, None, 3), (None, None, 7),
                                          (None, None, 4)])

        input_value = asfloat(np.random.random((1, 10, 10, 3)))
        actual_output = self.eval(network.output(input_value))
        self.assertEqual(actual_output.shape, (1, 10, 10, 4))

        input_value = asfloat(np.random.random((1, 7, 7, 3)))
        actual_output = self.eval(network.output(input_value))
        self.assertEqual(actual_output.shape, (1, 7, 7, 4))
示例#5
0
    def test_deconvolution_tuple_padding(self):
        network = layers.join(
            layers.Input((10, 10, 3)),
            layers.Convolution((3, 3, 7), padding=(9, 3)),
            layers.Deconvolution((3, 3, 4), padding=(9, 3)),
        )

        shapes = network.output_shapes_per_layer
        shapes = {l: shape_to_tuple(s) for l, s in shapes.items()}
        self.assertSequenceEqual(
            shapes, {
                network.layers[0]: (None, 10, 10, 3),
                network.layers[1]: (None, 26, 14, 7),
                network.layers[2]: (None, 10, 10, 4),
            })

        input_value = asfloat(np.random.random((1, 10, 10, 3)))
        actual_output = self.eval(network.output(input_value))

        self.assertEqual(actual_output.shape, (1, 10, 10, 4))
示例#6
0
    def test_deconv_unknown_input_width_and_height(self):
        network = layers.join(
            layers.Input((None, None, 3)),
            layers.Convolution((3, 3, 7)),
            layers.Deconvolution((3, 3, 4)),
        )

        shapes = network.output_shapes_per_layer
        shapes = {l: shape_to_tuple(s) for l, s in shapes.items()}
        self.assertDictEqual(
            shapes, {
                network.layers[0]: (None, None, None, 3),
                network.layers[1]: (None, None, None, 7),
                network.layers[2]: (None, None, None, 4),
            })

        input_value = asfloat(np.random.random((1, 10, 10, 3)))
        actual_output = self.eval(network.output(input_value))
        self.assertEqual(actual_output.shape, (1, 10, 10, 4))

        input_value = asfloat(np.random.random((1, 7, 7, 3)))
        actual_output = self.eval(network.output(input_value))
        self.assertEqual(actual_output.shape, (1, 7, 7, 4))