Python mxnet.gluon.nn.GlobalAvgPool2D() Examples
The following are 30
code examples of mxnet.gluon.nn.GlobalAvgPool2D().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
mxnet.gluon.nn
, or try the search function
.
.
Example #1
| Source File: cifarresnet.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=10,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(CIFARResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.Conv2D(channels[0], 3, 1, 1, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #2
| Source File: utils.py From EmotionClassifier with GNU General Public License v3.0 | 6 votes |
|
def resnet18(num_classes):
net = nn.HybridSequential()
with net.name_scope():
net.add(
nn.BatchNorm(),
nn.Conv2D(64, kernel_size=3, strides=1),
nn.MaxPool2D(pool_size=3, strides=2),
Residual(64),
Residual(64),
Residual(128, same_shape=False),
Residual(128),
Residual(256, same_shape=False),
Residual(256),
nn.GlobalAvgPool2D(),
nn.Dense(num_classes)
)
return net
Example #3
| Source File: mobilenet.py From gluon-cv with Apache License 2.0 | 6 votes |
|
def __init__(self, multiplier=1.0, classes=1000,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(MobileNet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
with self.features.name_scope():
_add_conv(self.features, channels=int(32 * multiplier), kernel=3, pad=1, stride=2,
norm_layer=norm_layer, norm_kwargs=norm_kwargs)
dw_channels = [int(x * multiplier) for x in [32, 64] + [128] * 2 +
[256] *
2 +
[512] *
6 +
[1024]]
channels = [int(x * multiplier) for x in [64] +
[128] * 2 + [256] * 2 + [512] * 6 + [1024] * 2]
strides = [1, 2] * 3 + [1] * 5 + [2, 1]
for dwc, c, s in zip(dw_channels, channels, strides):
_add_conv_dw(self.features, dw_channels=dwc, channels=c, stride=s,
norm_layer=norm_layer, norm_kwargs=norm_kwargs)
self.features.add(nn.GlobalAvgPool2D())
self.features.add(nn.Flatten())
self.output = nn.Dense(classes)
Example #4
| Source File: utils.py From d2l-zh with Apache License 2.0 | 6 votes |
|
def resnet18(num_classes):
"""The ResNet-18 model."""
net = nn.Sequential()
net.add(nn.Conv2D(64, kernel_size=3, strides=1, padding=1),
nn.BatchNorm(), nn.Activation('relu'))
def resnet_block(num_channels, num_residuals, first_block=False):
blk = nn.Sequential()
for i in range(num_residuals):
if i == 0 and not first_block:
blk.add(Residual(num_channels, use_1x1conv=True, strides=2))
else:
blk.add(Residual(num_channels))
return blk
net.add(resnet_block(64, 2, first_block=True),
resnet_block(128, 2),
resnet_block(256, 2),
resnet_block(512, 2))
net.add(nn.GlobalAvgPool2D(), nn.Dense(num_classes))
return net
Example #5
| Source File: resnet50_v2a.py From cascade_rcnn_gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, **kwargs):
super(ResNet50V2, self).__init__(**kwargs)
with self.name_scope():
self.rescale = nn.HybridSequential(prefix='')
self.rescale.add(Rescale(prefix=''))
self.layer0 = nn.HybridSequential(prefix='')
self.layer0.add(nn.BatchNorm(scale=False, epsilon=2e-5, use_global_stats=True))
self.layer0.add(nn.Conv2D(64, 7, 2, 3, use_bias=False))
self.layer0.add(nn.BatchNorm(epsilon=2e-5, use_global_stats=True))
self.layer0.add(nn.Activation('relu'))
self.layer0.add(nn.MaxPool2D(3, 2, 1))
self.layer1 = self._make_layer(stage_index=1, layers=3, in_channels=64,
channels=256, stride=1)
self.layer2 = self._make_layer(stage_index=2, layers=4, in_channels=256,
channels=512, stride=2)
self.layer3 = self._make_layer(stage_index=3, layers=6, in_channels=512,
channels=1024, stride=2)
self.layer4 = self._make_layer(stage_index=4, layers=3, in_channels=1024,
channels=2048, stride=1)
self.layer4.add(nn.BatchNorm(epsilon=2e-5, use_global_stats=True))
self.layer4.add(nn.Activation('relu'))
# self.layer4.add(nn.GlobalAvgPool2D())
# self.layer4.add(nn.Flatten())
Example #6
| Source File: resnet.py From gluon-cv with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=1000, thumbnail=False,
last_gamma=False, use_se=False, norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3(channels[0], 1, 0))
else:
self.features.add(nn.Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
last_gamma=last_gamma, use_se=use_se,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #7
| Source File: resnet50_v2a.py From cascade_rcnn_gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, **kwargs):
super(ResNet50V2, self).__init__(**kwargs)
with self.name_scope():
self.rescale = nn.HybridSequential(prefix='')
self.rescale.add(Rescale(prefix=''))
self.layer0 = nn.HybridSequential(prefix='')
self.layer0.add(nn.BatchNorm(scale=False, epsilon=2e-5, use_global_stats=True))
self.layer0.add(nn.Conv2D(64, 7, 2, 3, use_bias=False))
self.layer0.add(nn.BatchNorm(epsilon=2e-5, use_global_stats=True))
self.layer0.add(nn.Activation('relu'))
self.layer0.add(nn.MaxPool2D(3, 2, 1))
self.layer1 = self._make_layer(stage_index=1, layers=3, in_channels=64,
channels=256, stride=1)
self.layer2 = self._make_layer(stage_index=2, layers=4, in_channels=256,
channels=512, stride=2)
self.layer3 = self._make_layer(stage_index=3, layers=6, in_channels=512,
channels=1024, stride=2)
self.layer4 = self._make_layer(stage_index=4, layers=3, in_channels=1024,
channels=2048, stride=1)
self.layer4.add(nn.BatchNorm(epsilon=2e-5, use_global_stats=True))
self.layer4.add(nn.Activation('relu'))
# self.layer4.add(nn.GlobalAvgPool2D())
# self.layer4.add(nn.Flatten())
Example #8
| Source File: resnet.py From gluon-cv with Apache License 2.0 | 6 votes |
|
def __init__(self, depth, ctx, pretrained=True, num_classes=0):
super(ResNet, self).__init__()
self.pretrained = pretrained
with self.name_scope():
network = ResNet.__factory[depth](pretrained=pretrained, ctx=ctx).features[0:-1]
network[-1][0].body[0]._kwargs['stride'] = (1, 1)
network[-1][0].downsample[0]._kwargs['stride'] = (1, 1)
self.base = nn.HybridSequential()
for n in network:
self.base.add(n)
self.avgpool = nn.GlobalAvgPool2D()
self.flatten = nn.Flatten()
self.bn = nn.BatchNorm(center=False, scale=True)
self.bn.initialize(init=init.Zero(), ctx=ctx)
self.classifier = nn.Dense(num_classes, use_bias=False)
self.classifier.initialize(init=init.Normal(0.001), ctx=ctx)
Example #9
| Source File: utils.py From d2l-zh with Apache License 2.0 | 6 votes |
|
def resnet18(num_classes):
"""The ResNet-18 model."""
net = nn.Sequential()
net.add(nn.Conv2D(64, kernel_size=3, strides=1, padding=1),
nn.BatchNorm(), nn.Activation('relu'))
def resnet_block(num_channels, num_residuals, first_block=False):
blk = nn.Sequential()
for i in range(num_residuals):
if i == 0 and not first_block:
blk.add(Residual(num_channels, use_1x1conv=True, strides=2))
else:
blk.add(Residual(num_channels))
return blk
net.add(resnet_block(64, 2, first_block=True),
resnet_block(128, 2),
resnet_block(256, 2),
resnet_block(512, 2))
net.add(nn.GlobalAvgPool2D(), nn.Dense(num_classes))
return net
Example #10
| Source File: cifarresnet.py From gluon-cv with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=10,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(CIFARResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.Conv2D(channels[0], 3, 1, 1, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #11
| Source File: se_resnet.py From gluon-cv with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=1000, thumbnail=False,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(SE_ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3(channels[0], 1, 0))
else:
self.features.add(nn.Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #12
| Source File: cifarresnext.py From gluon-cv with Apache License 2.0 | 6 votes |
|
def __init__(self, layers, cardinality, bottleneck_width, classes=10,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(CIFARResNext, self).__init__(**kwargs)
self.cardinality = cardinality
self.bottleneck_width = bottleneck_width
channels = 64
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.Conv2D(channels, 3, 1, 1, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(channels, num_layer, stride, i+1,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
channels *= 2
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes)
Example #13
| Source File: quantized_mobilenet.py From Quantization.MXNet with MIT License | 6 votes |
|
def __init__(self, multiplier=1.0, classes=1000,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(MobileNet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
with self.features.name_scope():
_add_conv(self.features, channels=int(32 * multiplier), kernel=3, pad=1, stride=2, in_channels=3,
norm_layer=BatchNorm, norm_kwargs=None, quantized=False)
dw_channels = [int(x * multiplier) for x in [32, 64] + [128] * 2 +
[256] *
2 +
[512] *
6 +
[1024]]
channels = [int(x * multiplier) for x in [64] +
[128] * 2 + [256] * 2 + [512] * 6 + [1024] * 2]
strides = [1, 2] * 3 + [1] * 5 + [2, 1]
for dwc, c, s in zip(dw_channels, channels, strides):
_add_conv_dw(self.features, dw_channels=dwc, channels=c, stride=s,
norm_layer=BatchNorm, norm_kwargs=None)
self.features.add(nn.GlobalAvgPool2D())
self.features.add(nn.Flatten())
self.output = nn.Dense(classes)
Example #14
| Source File: utils_final.py From InsightFace_TF with MIT License | 6 votes |
|
def resnet18(num_classes):
net = nn.HybridSequential()
with net.name_scope():
net.add(
nn.BatchNorm(),
nn.Conv2D(64, kernel_size=3, strides=1),
nn.MaxPool2D(pool_size=3, strides=2),
Residual(64),
Residual(64),
Residual(128, same_shape=False),
Residual(128),
Residual(256, same_shape=False),
Residual(256),
nn.GlobalAvgPool2D(),
nn.Dense(num_classes)
)
return net
Example #15
| Source File: resnet.py From mxnet-centernet with MIT License | 6 votes |
|
def __init__(self, block, layers, channels, classes=1000, thumbnail=False,
last_gamma=False, use_se=False, norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3(channels[0], 1, 0))
else:
self.features.add(nn.Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
last_gamma=last_gamma, use_se=use_se,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #16
| Source File: resnet_symbol_plus_decoder.py From mxnet-centernet with MIT License | 6 votes |
|
def __init__(self, block, layers, channels, classes=1000, thumbnail=False,
last_gamma=False, use_se=False, norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3(channels[0], 1, 0))
else:
self.features.add(nn.Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
last_gamma=last_gamma, use_se=use_se,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #17
| Source File: resnet_symbol.py From mxnet-centernet with MIT License | 6 votes |
|
def __init__(self, block, layers, channels, classes=1000, thumbnail=False,
last_gamma=False, use_se=False, norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3(channels[0], 1, 0))
else:
self.features.add(nn.Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
last_gamma=last_gamma, use_se=use_se,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #18
| Source File: cifarresnext.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, layers, cardinality, bottleneck_width, classes=10,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(CIFARResNext, self).__init__(**kwargs)
self.cardinality = cardinality
self.bottleneck_width = bottleneck_width
channels = 64
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.Conv2D(channels, 3, 1, 1, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(channels, num_layer, stride, i+1,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
channels *= 2
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes)
Example #19
| Source File: bamresnet.py From imgclsmob with MIT License | 6 votes |
|
def __init__(self,
channels,
bn_use_global_stats,
reduction_ratio=16,
num_layers=1,
**kwargs):
super(ChannelGate, self).__init__(**kwargs)
mid_channels = channels // reduction_ratio
with self.name_scope():
self.pool = nn.GlobalAvgPool2D()
self.flatten = nn.Flatten()
self.init_fc = DenseBlock(
in_channels=channels,
out_channels=mid_channels,
bn_use_global_stats=bn_use_global_stats)
self.main_fcs = nn.HybridSequential(prefix="")
for i in range(num_layers - 1):
self.main_fcs.add(DenseBlock(
in_channels=mid_channels,
out_channels=mid_channels,
bn_use_global_stats=bn_use_global_stats))
self.final_fc = nn.Dense(
units=channels,
in_units=mid_channels)
Example #20
| Source File: cifarwideresnet.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, drop_rate, classes=10,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(CIFARWideResNet, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(norm_layer(scale=False, center=False,
**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Conv2D(channels[0], 3, 1, 1, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
in_channels = channels[0]
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1], drop_rate,
stride, i+1, in_channels=in_channels,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
in_channels = channels[i+1]
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.GlobalAvgPool2D())
self.features.add(nn.Flatten())
self.output = nn.Dense(classes)
Example #21
| Source File: resnet.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, depth, ctx, pretrained=True, num_classes=0):
super(ResNet, self).__init__()
self.pretrained = pretrained
with self.name_scope():
network = ResNet.__factory[depth](pretrained=pretrained, ctx=ctx).features[0:-1]
network[-1][0].body[0]._kwargs['stride'] = (1, 1)
network[-1][0].downsample[0]._kwargs['stride'] = (1, 1)
self.base = nn.HybridSequential()
for n in network:
self.base.add(n)
self.avgpool = nn.GlobalAvgPool2D()
self.flatten = nn.Flatten()
self.bn = nn.BatchNorm(center=False, scale=True)
self.bn.initialize(init=init.Zero(), ctx=ctx)
self.classifier = nn.Dense(num_classes, use_bias=False)
self.classifier.initialize(init=init.Normal(0.001), ctx=ctx)
Example #22
| Source File: resnext.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, layers, cardinality, bottleneck_width,
classes=1000, last_gamma=False, use_se=False,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(ResNext, self).__init__(**kwargs)
self.cardinality = cardinality
self.bottleneck_width = bottleneck_width
channels = 64
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.Conv2D(channels, 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(channels, num_layer, stride,
last_gamma, use_se, i+1,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
channels *= 2
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes)
Example #23
| Source File: se_resnet.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=1000, thumbnail=False,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(SE_ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3(channels[0], 1, 0))
else:
self.features.add(nn.Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #24
| Source File: cifarresnet.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=10,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(CIFARResNetV2, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(norm_layer(scale=False, center=False,
**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Conv2D(channels[0], 3, 1, 1, use_bias=False))
in_channels = channels[0]
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=in_channels,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
in_channels = channels[i+1]
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.GlobalAvgPool2D())
self.features.add(nn.Flatten())
self.output = nn.Dense(classes, in_units=in_channels)
Example #25
| Source File: mobilenet.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, multiplier=1.0, classes=1000,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(MobileNet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
with self.features.name_scope():
_add_conv(self.features, channels=int(32 * multiplier), kernel=3, pad=1, stride=2,
norm_layer=norm_layer, norm_kwargs=norm_kwargs)
dw_channels = [int(x * multiplier) for x in [32, 64] + [128] * 2 +
[256] *
2 +
[512] *
6 +
[1024]]
channels = [int(x * multiplier) for x in [64] +
[128] * 2 + [256] * 2 + [512] * 6 + [1024] * 2]
strides = [1, 2] * 3 + [1] * 5 + [2, 1]
for dwc, c, s in zip(dw_channels, channels, strides):
_add_conv_dw(self.features, dw_channels=dwc, channels=c, stride=s,
norm_layer=norm_layer, norm_kwargs=norm_kwargs)
self.features.add(nn.GlobalAvgPool2D())
self.features.add(nn.Flatten())
self.output = nn.Dense(classes)
Example #26
| Source File: resnet.py From panoptic-fpn-gluon with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=1000, thumbnail=False,
last_gamma=False, use_se=False, norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3(channels[0], 1, 0))
else:
self.features.add(nn.Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i],
last_gamma=last_gamma, use_se=use_se,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
Example #27
| Source File: cifarresnet.py From gluon-cv with Apache License 2.0 | 6 votes |
|
def __init__(self, block, layers, channels, classes=10,
norm_layer=BatchNorm, norm_kwargs=None, **kwargs):
super(CIFARResNetV2, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(norm_layer(scale=False, center=False,
**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Conv2D(channels[0], 3, 1, 1, use_bias=False))
in_channels = channels[0]
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=in_channels,
norm_layer=norm_layer, norm_kwargs=norm_kwargs))
in_channels = channels[i+1]
self.features.add(norm_layer(**({} if norm_kwargs is None else norm_kwargs)))
self.features.add(nn.Activation('relu'))
self.features.add(nn.GlobalAvgPool2D())
self.features.add(nn.Flatten())
self.output = nn.Dense(classes, in_units=in_channels)
Example #28
| Source File: MnasNet.py From Mnasnet-Pretrained-Model with Apache License 2.0 | 5 votes |
|
def __init__(self, num_classes=1000, **kwargs):
super(MobilenetV2, self).__init__(**kwargs)
self.first_oup = 32
self.interverted_residual_setting = [
# t, c, n, s, k
[3, 24, 3, 2, 3, "stage2_"], # -> 56x56
[3, 40, 3, 2, 5, "stage3_"], # -> 28x28
[6, 80, 3, 2, 5, "stage4_1_"], # -> 14x14
[6, 96, 2, 1, 3, "stage4_2_"], # -> 14x14
[6, 192, 4, 2, 5, "stage5_1_"], # -> 7x7
[6, 320, 1, 1, 3, "stage5_2_"], # -> 7x7
]
self.last_channels = 1280
with self.name_scope():
self.features = nn.HybridSequential()
self.features.add(ConvBlock(self.first_oup, 3, 2, prefix="stage1_conv0_"))
self.features.add(SepCONV(self.first_oup, 16, 3, prefix="stage1_sepconv0_"))
inp = 16
for i, (t, c, n, s, k, prefix) in enumerate(self.interverted_residual_setting):
oup = c
self.features.add(ExpandedConvSequence(t, k, inp, oup, n, s, prefix=prefix))
inp = oup
self.features.add(Conv1x1(self.last_channels, prefix="stage5_3_"))
self.features.add(nn.GlobalAvgPool2D())
self.features.add(nn.Flatten())
self.output = nn.Dense(num_classes)
Example #29
| Source File: nets.py From autogluon with Apache License 2.0 | 5 votes |
|
def mnist_net():
mnist_net = gluon.nn.Sequential()
mnist_net.add(ResUnit(1, 8, hidden_channels=8, kernel=3, stride=2))
mnist_net.add(ResUnit(8, 8, hidden_channels=8, kernel=5, stride=2))
mnist_net.add(ResUnit(8, 16, hidden_channels=8, kernel=3, stride=2))
mnist_net.add(nn.GlobalAvgPool2D())
mnist_net.add(nn.Flatten())
mnist_net.add(nn.Activation('relu'))
mnist_net.add(nn.Dense(10, in_units=16))
return mnist_net
Example #30
| Source File: fmobilenetv2.py From MaskInsightface with Apache License 2.0 | 5 votes |
|
def __init__(self, num_classes=1000, width_mult=1.0, **kwargs):
super(MobilenetV2, self).__init__(**kwargs)
self.w = width_mult
self.cn = [int(x*self.w) for x in [32, 16, 24, 32, 64, 96, 160, 320]]
def InvertedResidualSequence(t, cn_id, n, s):
seq = nn.HybridSequential()
seq.add(InvertedResidual(t, self.cn[cn_id-1], self.cn[cn_id], s, same_shape=False))
for _ in range(n-1):
seq.add(InvertedResidual(t, self.cn[cn_id-1], self.cn[cn_id], 1))
return seq
self.b0 = ConvBlock(self.cn[0], 3, 1)
self.b1 = InvertedResidualSequence(1, 1, 1, 1)
self.b2 = InvertedResidualSequence(6, 2, 2, 2)
self.b3 = InvertedResidualSequence(6, 3, 3, 2)
self.b4 = InvertedResidualSequence(6, 4, 4, 1)
self.b5 = InvertedResidualSequence(6, 5, 3, 2)
self.b6 = InvertedResidualSequence(6, 6, 3, 2)
self.b7 = InvertedResidualSequence(6, 7, 1, 1)
self.last_channels = int(1280*self.w) if self.w > 1.0 else 1280
with self.name_scope():
self.features = nn.HybridSequential()
with self.features.name_scope():
self.features.add(self.b0, self.b1, self.b2, self.b3, self.b4, self.b5, self.b6, self.b7)
self.features.add(Conv1x1(self.last_channels))
#self.features.add(nn.GlobalAvgPool2D())
#self.features.add(nn.Flatten())
#self.output = nn.Dense(num_classes)
