Add VoVNet model

README.md

@@ -105,6 +105,7 @@ Some remarks:
 | FishNet | A+ | A+ | A+ | - | - | [link](http://papers.nips.cc/paper/7356-fishnet-a-versatile-backbone-for-image-region-and-pixel-level-prediction.pdf) | [link](https://github.com/kevin-ssy/FishNet) | 2018 |
 | ESPNetv2 | A+ | A+ | A+ | - | - | [link](https://arxiv.org/abs/1811.11431) | [link](https://github.com/sacmehta/ESPNetv2) | 2018 |
 | HRNet | A+ | A+ | A+ | - | A+ | [link](https://arxiv.org/abs/1908.07919) | [link](https://github.com/HRNet/HRNet-Image-Classification) | 2019 |
+| VoVNet | A+ | A+ | A+ | - | A+ | [link](https://arxiv.org/abs/1904.09730) | [link](https://github.com/stigma0617/VoVNet.pytorch) | 2019 |
 | SelecSLS | A+ | A+ | A+ | - | A+ | [link](https://arxiv.org/abs/1907.00837) | [link](https://github.com/mehtadushy/SelecSLS-Pytorch) | 2019 |
 | X-DenseNet | AB+C+D+ | AB+C+D+ | AB+C+D+ | - | - | [link](https://arxiv.org/abs/1711.08757) | [link](https://github.com/DrImpossible/Deep-Expander-Networks) | 2017 |
 | SqueezeNet | A+ | A+ | A+ | A+ | A+ | [link](https://arxiv.org/abs/1602.07360) | [link](https://github.com/DeepScale/SqueezeNet) | 2016 |

chainer_/README.md

@@ -48,6 +48,7 @@ models are in the [`imgclsmob`](https://github.com/osmr/imgclsmob) repo.
 - FishNet (['FishNet: A Versatile Backbone for Image, Region, and Pixel Level Prediction'](http://papers.nips.cc/paper/7356-fishnet-a-versatile-backbone-for-image-region-and-pixel-level-prediction.pdf))
 - ESPNetv2 (['ESPNetv2: A Light-weight, Power Efficient, and General Purpose Convolutional Neural Network'](https://arxiv.org/abs/1811.11431))
 - HRNet (['Deep High-Resolution Representation Learning for Visual Recognition'](https://arxiv.org/abs/1908.07919))
+- VoVNet (['An Energy and GPU-Computation Efficient Backbone Network for Real-Time Object Detection'](https://arxiv.org/abs/1904.09730))
 - SelecSLS (['XNect: Real-time Multi-person 3D Human Pose Estimation with a Single RGB Camera'](https://arxiv.org/abs/1907.00837))
 - X-DenseNet (['Deep Expander Networks: Efficient Deep Networks from Graph Theory'](https://arxiv.org/abs/1711.08757))
 - SqueezeNet/SqueezeResNet (['SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size'](https://arxiv.org/abs/1602.07360))

chainer_/chainercv2/model_provider.py

@@ -36,6 +36,7 @@
 from .models.fishnet import *
 from .models.espnetv2 import *
 from .models.hrnet import *
+from .models.vovnet import *
 from .models.selecsls import *
 from .models.xdensenet import *
 from .models.squeezenet import *
@@ -385,6 +386,10 @@
     'hrnetv2_w48': hrnetv2_w48,
     'hrnetv2_w64': hrnetv2_w64,
 
+    'vovnet27s': vovnet27s,
+    'vovnet39': vovnet39,
+    'vovnet57': vovnet57,
+
     'selecsls42': selecsls42,
     'selecsls42b': selecsls42b,
     'selecsls60': selecsls60,
@@ -507,6 +512,7 @@
     'efficientnet_b5': efficientnet_b5,
     'efficientnet_b6': efficientnet_b6,
     'efficientnet_b7': efficientnet_b7,
+    'efficientnet_b8': efficientnet_b8,
     'efficientnet_b0b': efficientnet_b0b,
     'efficientnet_b1b': efficientnet_b1b,
     'efficientnet_b2b': efficientnet_b2b,
@@ -515,6 +521,15 @@
     'efficientnet_b5b': efficientnet_b5b,
     'efficientnet_b6b': efficientnet_b6b,
     'efficientnet_b7b': efficientnet_b7b,
+    'efficientnet_b0c': efficientnet_b0c,
+    'efficientnet_b1c': efficientnet_b1c,
+    'efficientnet_b2c': efficientnet_b2c,
+    'efficientnet_b3c': efficientnet_b3c,
+    'efficientnet_b4c': efficientnet_b4c,
+    'efficientnet_b5c': efficientnet_b5c,
+    'efficientnet_b6c': efficientnet_b6c,
+    'efficientnet_b7c': efficientnet_b7c,
+    'efficientnet_b8c': efficientnet_b8c,
 
     'mixnet_s': mixnet_s,
     'mixnet_m': mixnet_m,

chainer_/chainercv2/models/common.py

@@ -6,8 +6,8 @@
            'depthwise_conv3x3', 'ConvBlock', 'conv1x1_block', 'conv3x3_block', 'conv7x7_block', 'dwconv3x3_block',
            'dwconv5x5_block', 'dwsconv3x3_block', 'PreConvBlock', 'pre_conv1x1_block', 'pre_conv3x3_block',
            'ChannelShuffle', 'ChannelShuffle2', 'SEBlock', 'SimpleSequential', 'DualPathSequential', 'Concurrent',
-           'ParametricSequential', 'ParametricConcurrent', 'Hourglass', 'SesquialteralHourglass',
-           'MultiOutputSequential', 'Flatten', 'AdaptiveAvgPool2D']
+           'SequentialConcurrent', 'ParametricSequential', 'ParametricConcurrent', 'Hourglass',
+           'SesquialteralHourglass', 'MultiOutputSequential', 'Flatten', 'AdaptiveAvgPool2D']
 
 from inspect import isfunction
 from chainer import Chain
@@ -1095,6 +1095,41 @@ def __call__(self, x):
         return out
 
 
+class SequentialConcurrent(SimpleSequential):
+    """
+    A sequential container with concatenated outputs.
+    Blocks will be executed in the order they are added.
+
+    Parameters:
+    ----------
+    axis : int, default 1
+        The axis on which to concatenate the outputs.
+    stack : bool, default False
+        Whether to concatenate tensors along a new dimension.
+    cat_input : bool, default True
+        Whether to concatenate input tensor.
+    """
+    def __init__(self,
+                 axis=1,
+                 stack=False,
+                 cat_input=True):
+        super(SequentialConcurrent, self).__init__()
+        self.axis = axis
+        self.stack = stack
+        self.cat_input = cat_input
+
+    def __call__(self, x):
+        out = [x] if self.cat_input else []
+        for name in self.layer_names:
+            x = self[name](x)
+            out.append(x)
+        if self.stack:
+            out = F.stack(tuple(out), axis=self.axis)
+        else:
+            out = F.concat(tuple(out), axis=self.axis)
+        return out
+
+
 class ParametricSequential(SimpleSequential):
     """
     A sequential container for modules with parameters.

chainer_/chainercv2/models/efficientnet.py

@@ -5,9 +5,11 @@
 """
 
 __all__ = ['EfficientNet', 'efficientnet_b0', 'efficientnet_b1', 'efficientnet_b2', 'efficientnet_b3',
-           'efficientnet_b4', 'efficientnet_b5', 'efficientnet_b6', 'efficientnet_b7', 'efficientnet_b0b',
-           'efficientnet_b1b', 'efficientnet_b2b', 'efficientnet_b3b', 'efficientnet_b4b', 'efficientnet_b5b',
-           'efficientnet_b6b', 'efficientnet_b7b']
+           'efficientnet_b4', 'efficientnet_b5', 'efficientnet_b6', 'efficientnet_b7', 'efficientnet_b8',
+           'efficientnet_b0b', 'efficientnet_b1b', 'efficientnet_b2b', 'efficientnet_b3b', 'efficientnet_b4b',
+           'efficientnet_b5b', 'efficientnet_b6b', 'efficientnet_b7b', 'efficientnet_b0c', 'efficientnet_b1c',
+           'efficientnet_b2c', 'efficientnet_b3c', 'efficientnet_b4c', 'efficientnet_b5c', 'efficientnet_b6c',
+           'efficientnet_b7c', 'efficientnet_b8c']
 
 import os
 import math
@@ -612,6 +614,23 @@ def efficientnet_b7(in_size=(600, 600), **kwargs):
     return get_efficientnet(version="b7", in_size=in_size, model_name="efficientnet_b7", **kwargs)
 
 
+def efficientnet_b8(in_size=(672, 672), **kwargs):
+    """
+    EfficientNet-B8 model from 'EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks,'
+    https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (672, 672)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b8", in_size=in_size, model_name="efficientnet_b8", **kwargs)
+
+
 def efficientnet_b0b(in_size=(224, 224), **kwargs):
     """
     EfficientNet-B0-b (like TF-implementation) model from 'EfficientNet: Rethinking Model Scaling for Convolutional
@@ -756,6 +775,168 @@ def efficientnet_b7b(in_size=(600, 600), **kwargs):
                             **kwargs)
 
 
+def efficientnet_b0c(in_size=(224, 224), **kwargs):
+    """
+    EfficientNet-B0-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (224, 224)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b0", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b0c",
+                            **kwargs)
+
+
+def efficientnet_b1c(in_size=(240, 240), **kwargs):
+    """
+    EfficientNet-B1-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (240, 240)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b1", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b1c",
+                            **kwargs)
+
+
+def efficientnet_b2c(in_size=(260, 260), **kwargs):
+    """
+    EfficientNet-B2-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (260, 260)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b2", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b2c",
+                            **kwargs)
+
+
+def efficientnet_b3c(in_size=(300, 300), **kwargs):
+    """
+    EfficientNet-B3-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (300, 300)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b3", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b3c",
+                            **kwargs)
+
+
+def efficientnet_b4c(in_size=(380, 380), **kwargs):
+    """
+    EfficientNet-B4-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (380, 380)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b4", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b4c",
+                            **kwargs)
+
+
+def efficientnet_b5c(in_size=(456, 456), **kwargs):
+    """
+    EfficientNet-B5-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (456, 456)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b5", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b5c",
+                            **kwargs)
+
+
+def efficientnet_b6c(in_size=(528, 528), **kwargs):
+    """
+    EfficientNet-B6-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (528, 528)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b6", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b6c",
+                            **kwargs)
+
+
+def efficientnet_b7c(in_size=(600, 600), **kwargs):
+    """
+    EfficientNet-B7-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (600, 600)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b7", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b7c",
+                            **kwargs)
+
+
+def efficientnet_b8c(in_size=(672, 672), **kwargs):
+    """
+    EfficientNet-B8-c (like TF-implementation, trained with AdvProp) model from 'EfficientNet: Rethinking Model Scaling
+    for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946.
+
+    Parameters:
+    ----------
+    in_size : tuple of two ints, default (672, 672)
+        Spatial size of the expected input image.
+    pretrained : bool, default False
+        Whether to load the pretrained weights for model.
+    root : str, default '~/.chainer/models'
+        Location for keeping the model parameters.
+    """
+    return get_efficientnet(version="b8", in_size=in_size, tf_mode=True, bn_eps=1e-3, model_name="efficientnet_b8c",
+                            **kwargs)
+
+
 def _test():
     import numpy as np
     import chainer
@@ -773,6 +954,7 @@ def _test():
         efficientnet_b5,
         efficientnet_b6,
         efficientnet_b7,
+        efficientnet_b8,
         efficientnet_b0b,
         efficientnet_b1b,
         efficientnet_b2b,
@@ -781,6 +963,15 @@ def _test():
         efficientnet_b5b,
         efficientnet_b6b,
         efficientnet_b7b,
+        efficientnet_b0c,
+        efficientnet_b1c,
+        efficientnet_b2c,
+        efficientnet_b3c,
+        efficientnet_b4c,
+        efficientnet_b5c,
+        efficientnet_b6c,
+        efficientnet_b7c,
+        efficientnet_b8c,
     ]
 
     for model in models:
@@ -796,6 +987,7 @@ def _test():
         assert (model != efficientnet_b5 or weight_count == 30389784)
         assert (model != efficientnet_b6 or weight_count == 43040704)
         assert (model != efficientnet_b7 or weight_count == 66347960)
+        assert (model != efficientnet_b8 or weight_count == 87413142)
         assert (model != efficientnet_b0b or weight_count == 5288548)
         assert (model != efficientnet_b1b or weight_count == 7794184)
         assert (model != efficientnet_b2b or weight_count == 9109994)