openpoints 0.1.0__py3-none-any.whl

openpoints/models/backbone/randlenet.py

@@ -0,0 +1,318 @@
+import time
+
+import torch
+import torch.nn as nn
+from ..build import MODELS
+
+try:
+    from torch_points import knn
+except (ModuleNotFoundError, ImportError):
+    from torch_points_kernels import knn
+
+class SharedMLP(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        kernel_size=1,
+        stride=1,
+        transpose=False,
+        padding_mode='zeros',
+        bn=False,
+        activation_fn=None
+    ):
+        super(SharedMLP, self).__init__()
+
+        conv_fn = nn.ConvTranspose2d if transpose else nn.Conv2d
+
+        self.conv = conv_fn(
+            in_channels,
+            out_channels,
+            kernel_size,
+            stride=stride,
+            padding_mode=padding_mode
+        )
+        self.batch_norm = nn.BatchNorm2d(out_channels, eps=1e-6, momentum=0.99) if bn else None
+        self.activation_fn = activation_fn
+
+    def forward(self, input):
+        r"""
+            Forward pass of the network
+
+            Parameters
+            ----------
+            input: torch.Tensor, shape (B, d_in, N, K)
+
+            Returns
+            -------
+            torch.Tensor, shape (B, d_out, N, K)
+        """
+        x = self.conv(input)
+        if self.batch_norm:
+            x = self.batch_norm(x)
+        if self.activation_fn:
+            x = self.activation_fn(x)
+        return x
+
+
+class LocalSpatialEncoding(nn.Module):
+    def __init__(self, d, num_neighbors, device):
+        super(LocalSpatialEncoding, self).__init__()
+
+        self.num_neighbors = num_neighbors
+        self.mlp = SharedMLP(10, d, bn=True, activation_fn=nn.ReLU())
+
+        self.device = device
+
+    def forward(self, coords, features, knn_output):
+        r"""
+            Forward pass
+
+            Parameters
+            ----------
+            coords: torch.Tensor, shape (B, N, 3)
+                coordinates of the point cloud
+            features: torch.Tensor, shape (B, d, N, 1)
+                features of the point cloud
+            neighbors: tuple
+
+            Returns
+            -------
+            torch.Tensor, shape (B, 2*d, N, K)
+        """
+        # finding neighboring points
+        idx, dist = knn_output
+        B, N, K = idx.size()
+        # idx(B, N, K), coords(B, N, 3)
+        # neighbors[b, i, n, k] = coords[b, idx[b, n, k], i] = extended_coords[b, i, extended_idx[b, i, n, k], k]
+        extended_idx = idx.unsqueeze(1).expand(B, 3, N, K)
+        extended_coords = coords.transpose(-2,-1).unsqueeze(-1).expand(B, 3, N, K)
+        neighbors = torch.gather(extended_coords, 2, extended_idx) # shape (B, 3, N, K)
+        # if USE_CUDA:
+        #     neighbors = neighbors.cuda()
+
+        # relative point position encoding
+        concat = torch.cat((
+            extended_coords,
+            neighbors,
+            extended_coords - neighbors,
+            dist.unsqueeze(-3)
+        ), dim=-3).to(self.device)
+        return torch.cat((
+            self.mlp(concat),
+            features.expand(B, -1, N, K)
+        ), dim=-3)
+
+
+
+class AttentivePooling(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(AttentivePooling, self).__init__()
+
+        self.score_fn = nn.Sequential(
+            nn.Linear(in_channels, in_channels, bias=False),
+            nn.Softmax(dim=-2)
+        )
+        self.mlp = SharedMLP(in_channels, out_channels, bn=True, activation_fn=nn.ReLU())
+
+    def forward(self, x):
+        r"""
+            Forward pass
+
+            Parameters
+            ----------
+            x: torch.Tensor, shape (B, d_in, N, K)
+
+            Returns
+            -------
+            torch.Tensor, shape (B, d_out, N, 1)
+        """
+        # computing attention scores
+        scores = self.score_fn(x.permute(0,2,3,1)).permute(0,3,1,2)
+
+        # sum over the neighbors
+        features = torch.sum(scores * x, dim=-1, keepdim=True) # shape (B, d_in, N, 1)
+
+        return self.mlp(features)
+
+
+
+class LocalFeatureAggregation(nn.Module):
+    def __init__(self, d_in, d_out, num_neighbors, device):
+        super(LocalFeatureAggregation, self).__init__()
+
+        self.num_neighbors = num_neighbors
+
+        self.mlp1 = SharedMLP(d_in, d_out//2, activation_fn=nn.LeakyReLU(0.2))
+        self.mlp2 = SharedMLP(d_out, 2*d_out)
+        self.shortcut = SharedMLP(d_in, 2*d_out, bn=True)
+
+        self.lse1 = LocalSpatialEncoding(d_out//2, num_neighbors, device)
+        self.lse2 = LocalSpatialEncoding(d_out//2, num_neighbors, device)
+
+        self.pool1 = AttentivePooling(d_out, d_out//2)
+        self.pool2 = AttentivePooling(d_out, d_out)
+
+        self.lrelu = nn.LeakyReLU()
+
+    def forward(self, coords, features):
+        r"""
+            Forward pass
+
+            Parameters
+            ----------
+            coords: torch.Tensor, shape (B, N, 3)
+                coordinates of the point cloud
+            features: torch.Tensor, shape (B, d_in, N, 1)
+                features of the point cloud
+
+            Returns
+            -------
+            torch.Tensor, shape (B, 2*d_out, N, 1)
+        """
+        knn_output = knn(coords.cpu().contiguous(), coords.cpu().contiguous(), self.num_neighbors)
+
+        x = self.mlp1(features)
+
+        x = self.lse1(coords, x, knn_output)
+        x = self.pool1(x)
+
+        x = self.lse2(coords, x, knn_output)
+        x = self.pool2(x)
+
+        return self.lrelu(self.mlp2(x) + self.shortcut(features))
+
+
+@MODELS.register_module()
+class RandLANet(nn.Module):
+    def __init__(self, d_in, num_classes, num_neighbors=16, decimation=4, device=torch.device('cuda'), **kwargs):
+        super(RandLANet, self).__init__()
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.num_neighbors = num_neighbors
+        self.decimation = decimation
+
+        self.fc_start = nn.Linear(d_in, 8)
+        self.bn_start = nn.Sequential(
+            nn.BatchNorm2d(8, eps=1e-6, momentum=0.99),
+            nn.LeakyReLU(0.2)
+        )
+
+        # encoding layers
+        self.encoder = nn.ModuleList([
+            LocalFeatureAggregation(8, 16, num_neighbors, device),
+            LocalFeatureAggregation(32, 64, num_neighbors, device),
+            LocalFeatureAggregation(128, 128, num_neighbors, device),
+            LocalFeatureAggregation(256, 256, num_neighbors, device)
+        ])
+
+        self.mlp = SharedMLP(512, 512, activation_fn=nn.ReLU())
+
+        # decoding layers
+        decoder_kwargs = dict(
+            transpose=True,
+            bn=True,
+            activation_fn=nn.ReLU()
+        )
+        self.decoder = nn.ModuleList([
+            SharedMLP(1024, 256, **decoder_kwargs),
+            SharedMLP(512, 128, **decoder_kwargs),
+            SharedMLP(256, 32, **decoder_kwargs),
+            SharedMLP(64, 8, **decoder_kwargs)
+        ])
+
+        # final semantic prediction
+        self.fc_end = nn.Sequential(
+            SharedMLP(8, 64, bn=True, activation_fn=nn.ReLU()),
+            SharedMLP(64, 32, bn=True, activation_fn=nn.ReLU()),
+            nn.Dropout(),
+            SharedMLP(32, num_classes)
+        )
+        self.device = device
+
+        self = self.to(device)
+
+    def forward(self, input):
+        r"""
+            Forward pass
+
+            Parameters
+            ----------
+            input: torch.Tensor, shape (B, N, d_in)
+                input points
+
+            Returns
+            -------
+            torch.Tensor, shape (B, num_classes, N)
+                segmentation scores for each point
+        """
+        N = input.size(1)
+        d = self.decimation
+
+        coords = input[...,:3].clone().cpu()
+        x = self.fc_start(input).transpose(-2,-1).unsqueeze(-1)
+        x = self.bn_start(x) # shape (B, d, N, 1)
+
+        decimation_ratio = 1
+
+        # <<<<<<<<<< ENCODER
+        x_stack = []
+
+        permutation = torch.randperm(N)
+        coords = coords[:,permutation]
+        x = x[:,:,permutation]
+
+        for lfa in self.encoder:
+            # at iteration i, x.shape = (B, N//(d**i), d_in)
+            x = lfa(coords[:,:N//decimation_ratio], x)
+            x_stack.append(x.clone())
+            decimation_ratio *= d
+            x = x[:,:,:N//decimation_ratio]
+
+
+        # # >>>>>>>>>> ENCODER
+
+        x = self.mlp(x)
+
+        # <<<<<<<<<< DECODER
+        for mlp in self.decoder:
+            neighbors, _ = knn(
+                coords[:,:N//decimation_ratio].cpu().contiguous(), # original set
+                coords[:,:d*N//decimation_ratio].cpu().contiguous(), # upsampled set
+                1
+            ) # shape (B, N, 1)
+            neighbors = neighbors.to(self.device)
+
+            extended_neighbors = neighbors.unsqueeze(1).expand(-1, x.size(1), -1, 1)
+
+            x_neighbors = torch.gather(x, -2, extended_neighbors)
+
+            x = torch.cat((x_neighbors, x_stack.pop()), dim=1)
+
+            x = mlp(x)
+
+            decimation_ratio //= d
+
+        # >>>>>>>>>> DECODER
+        # inverse permutation
+        x = x[:,:,torch.argsort(permutation)]
+
+        scores = self.fc_end(x)
+
+        return scores.squeeze(-1)
+
+
+if __name__ == '__main__':
+    import time
+    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+
+    d_in = 7
+    cloud = 1000*torch.randn(1, 2**16, d_in).to(device)
+    model = RandLANet(d_in, 6, 16, 4, device)
+    # model.load_state_dict(torch.load('checkpoints/checkpoint_100.pth'))
+    model.eval()
+
+    t0 = time.time()
+    pred = model(cloud)
+    t1 = time.time()
+    # print(pred)
+    print(t1-t0)

openpoints/models/backbone/resnet.py

@@ -0,0 +1,342 @@
+import torch
+import torch.nn as nn
+from torch.hub import load_state_dict_from_url
+
+
+__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+           'resnet152', 'resnext50_32x4d', 'resnext101_32x8d',
+           'wide_resnet50_2', 'wide_resnet101_2']
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
+    'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, groups=groups, bias=False, dilation=dilation)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)
+    # while original implementation places the stride at the first 1x1 convolution(self.conv1)
+    # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385.
+    # This variant is also known as ResNet V1.5 and improves accuracy according to
+    # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.
+
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
+                 groups=1, width_per_group=64, replace_stride_with_dilation=None,
+                 norm_layer=None, feature_size=64):
+        super(ResNet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = feature_size
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, feature_size, layers[0])
+        self.layer2 = self._make_layer(block, feature_size * 2, layers[1], stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        self.layer3 = self._make_layer(block, feature_size * 4, layers[2], stride=2,
+                                       dilate=replace_stride_with_dilation[1])
+        self.layer4 = self._make_layer(block, feature_size * 8, layers[3], stride=2,
+                                       dilate=replace_stride_with_dilation[2])
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(feature_size * 8 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer))
+
+        return nn.Sequential(*layers)
+
+    def _forward_impl(self, x):
+        # See note [TorchScript super()]
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+        x = self.fc(x)
+
+        return x
+
+    def forward(self, x):
+        return self._forward_impl(x)
+
+
+def _resnet(arch, block, layers, pretrained, progress, **kwargs):
+    model = ResNet(block, layers, **kwargs)
+    if pretrained:
+        state_dict = load_state_dict_from_url(model_urls[arch],
+                                              progress=progress)
+        model.load_state_dict(state_dict)
+    return model
+
+
+def resnet18(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-18 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,
+                   **kwargs)
+
+
+def resnet34(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-34 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet50(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-50 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet101(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-101 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet152(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-152 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnext50_32x4d(pretrained=False, progress=True, **kwargs):
+    r"""ResNeXt-50 32x4d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 4
+    return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3],
+                   pretrained, progress, **kwargs)
+
+
+def resnext101_32x8d(pretrained=False, progress=True, **kwargs):
+    r"""ResNeXt-101 32x8d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 8
+    return _resnet('resnext101_32x8d', Bottleneck, [3, 4, 23, 3],
+                   pretrained, progress, **kwargs)
+
+
+def wide_resnet50_2(pretrained=False, progress=True, **kwargs):
+    r"""Wide ResNet-50-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet50_2', Bottleneck, [3, 4, 6, 3],
+                   pretrained, progress, **kwargs)
+
+
+def wide_resnet101_2(pretrained=False, progress=True, **kwargs):
+    r"""Wide ResNet-101-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet101_2', Bottleneck, [3, 4, 23, 3],
+                   pretrained, progress, **kwargs)