Merge pull request #5107 from takagi/dtype-vgg16

Support default dtype in `L.VGG16Layers`

chainer/links/model/vision/vgg.py

@@ -338,6 +338,7 @@ def prepare(image, size=(224, 224)):
         raise ImportError('PIL cannot be loaded. Install Pillow!\n'
                           'The actual import error is as follows:\n' +
                           str(_import_error))
+    dtype = chainer.get_dtype()
     if isinstance(image, numpy.ndarray):
         if image.ndim == 3:
             if image.shape[0] == 1:
@@ -348,10 +349,10 @@ def prepare(image, size=(224, 224)):
     image = image.convert('RGB')
     if size:
         image = image.resize(size)
-    image = numpy.asarray(image, dtype=numpy.float32)
+    image = numpy.asarray(image, dtype=dtype)
     image = image[:, :, ::-1]
     image -= numpy.array(
-        [103.939, 116.779, 123.68], dtype=numpy.float32)
+        [103.939, 116.779, 123.68], dtype=dtype)
     image = image.transpose((2, 0, 1))
     return image
 

tests/chainer_tests/links_tests/model_tests/test_vision.py

@@ -163,13 +163,21 @@ def test_copy_gpu(self):
         self.check_copy()
 
 
+@testing.parameterize(*testing.product({
+    'dtype': [numpy.float16, numpy.float32],
+}))
 @unittest.skipUnless(resnet.available, 'Pillow is required')
 @attr.slow
 class TestVGG16Layers(unittest.TestCase):
 
     def setUp(self):
+        self._config_user = chainer.using_config('dtype', self.dtype)
+        self._config_user.__enter__()
         self.link = vgg.VGG16Layers(pretrained_model=None)
 
+    def tearDown(self):
+        self._config_user.__exit__(None, None, None)
+
     def test_available_layers(self):
         result = self.link.available_layers
         self.assertIsInstance(result, list)
@@ -179,7 +187,7 @@ def check_call(self):
         xp = self.link.xp
 
         x1 = Variable(xp.asarray(numpy.random.uniform(
-            -1, 1, (1, 3, 224, 224)).astype(numpy.float32)))
+            -1, 1, (1, 3, 224, 224)).astype(self.dtype)))
         y1 = cuda.to_cpu(self.link(x1)['prob'].data)
         self.assertEqual(y1.shape, (1, 1000))
 
@@ -194,25 +202,25 @@ def test_call_gpu(self):
     def test_prepare(self):
         x1 = numpy.random.uniform(0, 255, (320, 240, 3)).astype(numpy.uint8)
         x2 = numpy.random.uniform(0, 255, (320, 240)).astype(numpy.uint8)
-        x3 = numpy.random.uniform(0, 255, (160, 120, 3)).astype(numpy.float32)
-        x4 = numpy.random.uniform(0, 255, (1, 160, 120)).astype(numpy.float32)
+        x3 = numpy.random.uniform(0, 255, (160, 120, 3)).astype(self.dtype)
+        x4 = numpy.random.uniform(0, 255, (1, 160, 120)).astype(self.dtype)
         x5 = numpy.random.uniform(0, 255, (3, 160, 120)).astype(numpy.uint8)
 
         y1 = vgg.prepare(x1)
         self.assertEqual(y1.shape, (3, 224, 224))
-        self.assertEqual(y1.dtype, numpy.float32)
+        self.assertEqual(y1.dtype, self.dtype)
         y2 = vgg.prepare(x2)
         self.assertEqual(y2.shape, (3, 224, 224))
-        self.assertEqual(y2.dtype, numpy.float32)
+        self.assertEqual(y2.dtype, self.dtype)
         y3 = vgg.prepare(x3, size=None)
         self.assertEqual(y3.shape, (3, 160, 120))
-        self.assertEqual(y3.dtype, numpy.float32)
+        self.assertEqual(y3.dtype, self.dtype)
         y4 = vgg.prepare(x4)
         self.assertEqual(y4.shape, (3, 224, 224))
-        self.assertEqual(y4.dtype, numpy.float32)
+        self.assertEqual(y4.dtype, self.dtype)
         y5 = vgg.prepare(x5, size=None)
         self.assertEqual(y5.shape, (3, 160, 120))
-        self.assertEqual(y5.dtype, numpy.float32)
+        self.assertEqual(y5.dtype, self.dtype)
 
     def check_extract(self):
         x1 = numpy.random.uniform(0, 255, (320, 240, 3)).astype(numpy.uint8)
@@ -221,17 +229,17 @@ def check_extract(self):
         self.assertEqual(len(result), 2)
         y1 = cuda.to_cpu(result['pool3'].data)
         self.assertEqual(y1.shape, (2, 256, 28, 28))
-        self.assertEqual(y1.dtype, numpy.float32)
+        self.assertEqual(y1.dtype, self.dtype)
         y2 = cuda.to_cpu(result['fc7'].data)
         self.assertEqual(y2.shape, (2, 4096))
-        self.assertEqual(y2.dtype, numpy.float32)
+        self.assertEqual(y2.dtype, self.dtype)
 
         x3 = numpy.random.uniform(0, 255, (80, 60)).astype(numpy.uint8)
         result = self.link.extract([x3], layers=['pool1'], size=None)
         self.assertEqual(len(result), 1)
         y3 = cuda.to_cpu(result['pool1'].data)
         self.assertEqual(y3.shape, (1, 64, 40, 30))
-        self.assertEqual(y3.dtype, numpy.float32)
+        self.assertEqual(y3.dtype, self.dtype)
 
     def test_extract_cpu(self):
         self.check_extract()
@@ -247,11 +255,11 @@ def check_predict(self):
         result = self.link.predict([x1, x2], oversample=False)
         y = cuda.to_cpu(result.data)
         self.assertEqual(y.shape, (2, 1000))
-        self.assertEqual(y.dtype, numpy.float32)
+        self.assertEqual(y.dtype, self.dtype)
         result = self.link.predict([x1, x2], oversample=True)
         y = cuda.to_cpu(result.data)
         self.assertEqual(y.shape, (2, 1000))
-        self.assertEqual(y.dtype, numpy.float32)
+        self.assertEqual(y.dtype, self.dtype)
 
     def test_predict_cpu(self):
         self.check_predict()