Spaces:
Runtime error
Runtime error
# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve. | |
# | |
# Licensed under the Apache License, Version 2.0 (the "License"); | |
# you may not use this file except in compliance with the License. | |
# You may obtain a copy of the License at | |
# | |
# http://www.apache.org/licenses/LICENSE-2.0 | |
# | |
# Unless required by applicable law or agreed to in writing, software | |
# distributed under the License is distributed on an "AS IS" BASIS, | |
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
# See the License for the specific language governing permissions and | |
# limitations under the License. | |
from __future__ import absolute_import | |
from __future__ import division | |
from __future__ import print_function | |
import paddle | |
from paddle import ParamAttr | |
import paddle.nn as nn | |
import paddle.nn.functional as F | |
__all__ = ["ResNet"] | |
class ConvBNLayer(nn.Layer): | |
def __init__( | |
self, | |
in_channels, | |
out_channels, | |
kernel_size, | |
stride=1, | |
groups=1, | |
is_vd_mode=False, | |
act=None, | |
name=None, ): | |
super(ConvBNLayer, self).__init__() | |
self.is_vd_mode = is_vd_mode | |
self._pool2d_avg = nn.AvgPool2D( | |
kernel_size=stride, stride=stride, padding=0, ceil_mode=True) | |
self._conv = nn.Conv2D( | |
in_channels=in_channels, | |
out_channels=out_channels, | |
kernel_size=kernel_size, | |
stride=1 if is_vd_mode else stride, | |
padding=(kernel_size - 1) // 2, | |
groups=groups, | |
weight_attr=ParamAttr(name=name + "_weights"), | |
bias_attr=False) | |
if name == "conv1": | |
bn_name = "bn_" + name | |
else: | |
bn_name = "bn" + name[3:] | |
self._batch_norm = nn.BatchNorm( | |
out_channels, | |
act=act, | |
param_attr=ParamAttr(name=bn_name + '_scale'), | |
bias_attr=ParamAttr(bn_name + '_offset'), | |
moving_mean_name=bn_name + '_mean', | |
moving_variance_name=bn_name + '_variance') | |
def forward(self, inputs): | |
if self.is_vd_mode: | |
inputs = self._pool2d_avg(inputs) | |
y = self._conv(inputs) | |
y = self._batch_norm(y) | |
return y | |
class BottleneckBlock(nn.Layer): | |
def __init__(self, | |
in_channels, | |
out_channels, | |
stride, | |
shortcut=True, | |
if_first=False, | |
name=None): | |
super(BottleneckBlock, self).__init__() | |
self.conv0 = ConvBNLayer( | |
in_channels=in_channels, | |
out_channels=out_channels, | |
kernel_size=1, | |
act='relu', | |
name=name + "_branch2a") | |
self.conv1 = ConvBNLayer( | |
in_channels=out_channels, | |
out_channels=out_channels, | |
kernel_size=3, | |
stride=stride, | |
act='relu', | |
name=name + "_branch2b") | |
self.conv2 = ConvBNLayer( | |
in_channels=out_channels, | |
out_channels=out_channels * 4, | |
kernel_size=1, | |
act=None, | |
name=name + "_branch2c") | |
if not shortcut: | |
self.short = ConvBNLayer( | |
in_channels=in_channels, | |
out_channels=out_channels * 4, | |
kernel_size=1, | |
stride=stride, | |
is_vd_mode=not if_first and stride[0] != 1, | |
name=name + "_branch1") | |
self.shortcut = shortcut | |
def forward(self, inputs): | |
y = self.conv0(inputs) | |
conv1 = self.conv1(y) | |
conv2 = self.conv2(conv1) | |
if self.shortcut: | |
short = inputs | |
else: | |
short = self.short(inputs) | |
y = paddle.add(x=short, y=conv2) | |
y = F.relu(y) | |
return y | |
class BasicBlock(nn.Layer): | |
def __init__(self, | |
in_channels, | |
out_channels, | |
stride, | |
shortcut=True, | |
if_first=False, | |
name=None): | |
super(BasicBlock, self).__init__() | |
self.stride = stride | |
self.conv0 = ConvBNLayer( | |
in_channels=in_channels, | |
out_channels=out_channels, | |
kernel_size=3, | |
stride=stride, | |
act='relu', | |
name=name + "_branch2a") | |
self.conv1 = ConvBNLayer( | |
in_channels=out_channels, | |
out_channels=out_channels, | |
kernel_size=3, | |
act=None, | |
name=name + "_branch2b") | |
if not shortcut: | |
self.short = ConvBNLayer( | |
in_channels=in_channels, | |
out_channels=out_channels, | |
kernel_size=1, | |
stride=stride, | |
is_vd_mode=not if_first and stride[0] != 1, | |
name=name + "_branch1") | |
self.shortcut = shortcut | |
def forward(self, inputs): | |
y = self.conv0(inputs) | |
conv1 = self.conv1(y) | |
if self.shortcut: | |
short = inputs | |
else: | |
short = self.short(inputs) | |
y = paddle.add(x=short, y=conv1) | |
y = F.relu(y) | |
return y | |
class ResNet(nn.Layer): | |
def __init__(self, in_channels=3, layers=50, **kwargs): | |
super(ResNet, self).__init__() | |
self.layers = layers | |
supported_layers = [18, 34, 50, 101, 152, 200] | |
assert layers in supported_layers, \ | |
"supported layers are {} but input layer is {}".format( | |
supported_layers, layers) | |
if layers == 18: | |
depth = [2, 2, 2, 2] | |
elif layers == 34 or layers == 50: | |
depth = [3, 4, 6, 3] | |
elif layers == 101: | |
depth = [3, 4, 23, 3] | |
elif layers == 152: | |
depth = [3, 8, 36, 3] | |
elif layers == 200: | |
depth = [3, 12, 48, 3] | |
num_channels = [64, 256, 512, | |
1024] if layers >= 50 else [64, 64, 128, 256] | |
num_filters = [64, 128, 256, 512] | |
self.conv1_1 = ConvBNLayer( | |
in_channels=in_channels, | |
out_channels=32, | |
kernel_size=3, | |
stride=1, | |
act='relu', | |
name="conv1_1") | |
self.conv1_2 = ConvBNLayer( | |
in_channels=32, | |
out_channels=32, | |
kernel_size=3, | |
stride=1, | |
act='relu', | |
name="conv1_2") | |
self.conv1_3 = ConvBNLayer( | |
in_channels=32, | |
out_channels=64, | |
kernel_size=3, | |
stride=1, | |
act='relu', | |
name="conv1_3") | |
self.pool2d_max = nn.MaxPool2D(kernel_size=3, stride=2, padding=1) | |
self.block_list = [] | |
if layers >= 50: | |
for block in range(len(depth)): | |
shortcut = False | |
for i in range(depth[block]): | |
if layers in [101, 152, 200] and block == 2: | |
if i == 0: | |
conv_name = "res" + str(block + 2) + "a" | |
else: | |
conv_name = "res" + str(block + 2) + "b" + str(i) | |
else: | |
conv_name = "res" + str(block + 2) + chr(97 + i) | |
if i == 0 and block != 0: | |
stride = (2, 1) | |
else: | |
stride = (1, 1) | |
bottleneck_block = self.add_sublayer( | |
'bb_%d_%d' % (block, i), | |
BottleneckBlock( | |
in_channels=num_channels[block] | |
if i == 0 else num_filters[block] * 4, | |
out_channels=num_filters[block], | |
stride=stride, | |
shortcut=shortcut, | |
if_first=block == i == 0, | |
name=conv_name)) | |
shortcut = True | |
self.block_list.append(bottleneck_block) | |
self.out_channels = num_filters[block] * 4 | |
else: | |
for block in range(len(depth)): | |
shortcut = False | |
for i in range(depth[block]): | |
conv_name = "res" + str(block + 2) + chr(97 + i) | |
if i == 0 and block != 0: | |
stride = (2, 1) | |
else: | |
stride = (1, 1) | |
basic_block = self.add_sublayer( | |
'bb_%d_%d' % (block, i), | |
BasicBlock( | |
in_channels=num_channels[block] | |
if i == 0 else num_filters[block], | |
out_channels=num_filters[block], | |
stride=stride, | |
shortcut=shortcut, | |
if_first=block == i == 0, | |
name=conv_name)) | |
shortcut = True | |
self.block_list.append(basic_block) | |
self.out_channels = num_filters[block] | |
self.out_pool = nn.MaxPool2D(kernel_size=2, stride=2, padding=0) | |
def forward(self, inputs): | |
y = self.conv1_1(inputs) | |
y = self.conv1_2(y) | |
y = self.conv1_3(y) | |
y = self.pool2d_max(y) | |
for block in self.block_list: | |
y = block(y) | |
y = self.out_pool(y) | |
return y | |