Beispiel #1
0
    def testConstructor(self):

        with self.assertRaisesRegexp(ValueError,
                                     "output_shapes must be of length 1 or *"):
            snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                        output_shapes=[],
                                        kernel_shapes=self.kernel_shapes,
                                        strides=self.strides,
                                        paddings=self.paddings)

        with self.assertRaisesRegexp(ValueError,
                                     "output_shapes must be of length 1 or *"):
            snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                        output_shapes=[[1, 2], [1, 2]],
                                        kernel_shapes=self.kernel_shapes,
                                        strides=[],
                                        paddings=self.paddings)

        with self.assertRaisesRegexp(KeyError, "Invalid initializer keys.*"):
            snt.nets.ConvNet2DTranspose(
                output_channels=self.output_channels,
                output_shapes=self.output_shapes,
                kernel_shapes=self.kernel_shapes,
                strides=self.strides,
                paddings=self.paddings,
                initializers={
                    "not_w": tf.truncated_normal_initializer(stddev=1.0)
                })

        net = snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                          output_shapes=self.output_shapes,
                                          kernel_shapes=self.kernel_shapes,
                                          strides=self.strides,
                                          paddings=self.paddings)
        self.assertEqual(net.output_shapes,
                         tuple(self.output_shapes) * len(self.output_channels))
        self.assertEqual(len(net.layers), len(self.output_channels))

        for i, layer in enumerate(net.layers):
            self.assertEqual(layer.output_channels, self.output_channels[i])
            self.assertEqual(layer.stride,
                             (1, ) + fill_shape(self.strides[0], 2) + (1, ))
            self.assertEqual(layer.kernel_shape,
                             fill_shape(self.kernel_shapes[0], 2))
            self.assertEqual(layer.padding, self.paddings[0])
            self.assertEqual(layer.output_channels, net.output_channels[i])
            self.assertEqual(layer.stride,
                             (1, ) + fill_shape(net.strides[i], 2) + (1, ))
            self.assertEqual(layer.kernel_shape,
                             fill_shape(net.kernel_shapes[i], 2))
            self.assertEqual(layer.padding, net.paddings[i])

        with self.assertRaisesRegexp(TypeError,
                                     "output_shapes must be iterable"):
            snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                        output_shapes=False,
                                        kernel_shapes=self.kernel_shapes,
                                        strides=self.strides,
                                        paddings=self.paddings)
Beispiel #2
0
  def testConstructor(self):

    with self.assertRaisesRegexp(ValueError,
                                 "output_shapes must be of length 1 or *"):
      snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                  output_shapes=[],
                                  kernel_shapes=self.kernel_shapes,
                                  strides=self.strides,
                                  paddings=self.paddings)

    with self.assertRaisesRegexp(ValueError,
                                 "output_shapes must be of length 1 or *"):
      snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                  output_shapes=[[1, 2], [1, 2]],
                                  kernel_shapes=self.kernel_shapes,
                                  strides=[],
                                  paddings=self.paddings)

    with self.assertRaisesRegexp(KeyError,
                                 "Invalid initializer keys.*"):
      snt.nets.ConvNet2DTranspose(
          output_channels=self.output_channels,
          output_shapes=self.output_shapes,
          kernel_shapes=self.kernel_shapes,
          strides=self.strides,
          paddings=self.paddings,
          initializers={"not_w": tf.truncated_normal_initializer(stddev=1.0)})

    net = snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                      output_shapes=self.output_shapes,
                                      kernel_shapes=self.kernel_shapes,
                                      strides=self.strides,
                                      paddings=self.paddings)
    self.assertEqual(net.output_shapes,
                     tuple(self.output_shapes) * len(self.output_channels))
    self.assertEqual(len(net.layers), len(self.output_channels))

    for i, layer in enumerate(net.layers):
      self.assertEqual(layer.output_channels, self.output_channels[i])
      self.assertEqual(layer.stride,
                       (1,) + fill_shape(self.strides[0], 2) + (1,))
      self.assertEqual(layer.kernel_shape, fill_shape(self.kernel_shapes[0], 2))
      self.assertEqual(layer.padding, self.paddings[0])
      self.assertEqual(layer.output_channels, net.output_channels[i])
      self.assertEqual(layer.stride,
                       (1,) + fill_shape(net.strides[i], 2) + (1,))
      self.assertEqual(layer.kernel_shape, fill_shape(net.kernel_shapes[i], 2))
      self.assertEqual(layer.padding, net.paddings[i])

    with self.assertRaisesRegexp(TypeError, "output_shapes must be iterable"):
      snt.nets.ConvNet2DTranspose(output_channels=self.output_channels,
                                  output_shapes=False,
                                  kernel_shapes=self.kernel_shapes,
                                  strides=self.strides,
                                  paddings=self.paddings)
Beispiel #3
0
  def testConstructor(self):
    net = snt.nets.ConvNet2D(output_channels=self.output_channels,
                             kernel_shapes=self.kernel_shapes,
                             strides=self.strides,
                             paddings=self.paddings)
    self.assertEqual(len(net.layers), len(self.output_channels))

    for i, layer in enumerate(net.layers):
      self.assertEqual(layer.output_channels, self.output_channels[i])
      self.assertEqual(layer.stride,
                       (1,) + fill_shape(self.strides[0], 2) + (1,))
      self.assertEqual(layer.kernel_shape, fill_shape(self.kernel_shapes[0], 2))
      self.assertEqual(layer.padding, self.paddings[0])
      self.assertEqual(layer.output_channels, net.output_channels[i])
      self.assertEqual(layer.stride,
                       (1,) + fill_shape(net.strides[i], 2) + (1,))
      self.assertEqual(layer.kernel_shape, fill_shape(net.kernel_shapes[i], 2))
      self.assertEqual(layer.padding, net.paddings[i])