def construct(self, input_x):
"""Callback method."""
out = P.ReLU()(self.conv1(input_x))
out = P.MaxPool(2, None, 'valid')(out)
out = P.ReLU()(self.conv2(out))
out = P.MaxPool(2, None, 'valid')(out)
out = P.Reshape()(out, (
P.Shape()(out)[0],
-1,
))
out = P.ReLU()(self.fc1(out))
out = P.ReLU()(self.fc2(out))
out = self.fc3(out)
return out
def __init__(self, in_channels, out_channels, num_outs):
super(FeatPyramidNeck, self).__init__()
self.num_outs = num_outs
self.in_channels = in_channels
self.fpn_layer = len(self.in_channels)
assert not self.num_outs < len(in_channels)
self.lateral_convs_list_ = []
self.fpn_convs_ = []
for _, channel in enumerate(in_channels):
l_conv = _conv(channel,
out_channels,
kernel_size=1,
stride=1,
padding=0,
pad_mode='valid')
fpn_conv = _conv(out_channels,
out_channels,
kernel_size=3,
stride=1,
padding=0,
pad_mode='same')
self.lateral_convs_list_.append(l_conv)
self.fpn_convs_.append(fpn_conv)
self.lateral_convs_list = nn.layer.CellList(self.lateral_convs_list_)
self.fpn_convs_list = nn.layer.CellList(self.fpn_convs_)
self.interpolate1 = P.ResizeNearestNeighbor((48, 80))
self.interpolate2 = P.ResizeNearestNeighbor((96, 160))
self.interpolate3 = P.ResizeNearestNeighbor((192, 320))
self.maxpool = P.MaxPool(ksize=1, strides=2, padding="same")
def __init__(self, kernel_size=1, stride=1, pad_mode="valid"):
super(MaxPool2d, self).__init__(kernel_size, stride, pad_mode)
self.max_pool = P.MaxPool(ksize=self.kernel_size,
strides=self.stride,
padding=self.pad_mode)
self.max_pool_with_arg_max = P.MaxPoolWithArgmax(
ksize=self.kernel_size, strides=self.stride, padding=self.pad_mode)
self.is_tbe = context.get_context("device_target") == "Ascend"
def __init__(self,
block,
layer_nums,
in_channels,
out_channels,
weights_update=False):
super(ResNetFea, self).__init__()
if not len(layer_nums) == len(in_channels) == len(out_channels) == 4:
raise ValueError(
"the length of "
"layer_num, inchannel, outchannel list must be 4!")
bn_training = False
self.conv1 = _conv(3,
64,
kernel_size=7,
stride=2,
padding=3,
pad_mode='pad')
self.bn1 = _BatchNorm2dInit(64,
affine=bn_training,
use_batch_statistics=bn_training)
self.relu = P.ReLU()
self.maxpool = P.MaxPool(kernel_size=3, strides=2, pad_mode="SAME")
self.weights_update = weights_update
if not self.weights_update:
self.conv1.weight.requires_grad = False
self.layer1 = self._make_layer(block,
layer_nums[0],
in_channel=in_channels[0],
out_channel=out_channels[0],
stride=1,
training=bn_training,
weights_update=self.weights_update)
self.layer2 = self._make_layer(block,
layer_nums[1],
in_channel=in_channels[1],
out_channel=out_channels[1],
stride=2,
training=bn_training,
weights_update=True)
self.layer3 = self._make_layer(block,
layer_nums[2],
in_channel=in_channels[2],
out_channel=out_channels[2],
stride=2,
training=bn_training,
weights_update=True)
self.layer4 = self._make_layer(block,
layer_nums[3],
in_channel=in_channels[3],
out_channel=out_channels[3],
stride=2,
training=bn_training,
weights_update=True)
def __init__(self, w1, w2):
super(Conv2dBpropInputInplace, self).__init__()
self.conv2d_1 = P.Conv2DBackpropInput(out_channel=256, kernel_size=1)
self.w1 = Parameter(initializer(w1, w1.shape), name='w1')
self.conv2d_2 = P.Conv2DBackpropInput(out_channel=256, kernel_size=1)
self.w2 = Parameter(initializer(w2, w2.shape), name='w2')
self.add = P.TensorAdd()
self.maxpool = P.MaxPool(kernel_size=3, strides=2, pad_mode='SAME')
self.maxpool_grad = G.MaxPoolGrad(kernel_size=3, strides=2, pad_mode='SAME')
self.shape = (32, 64, 56, 56)
def __init__(self,
kernel_size=1,
stride=1,
pad_mode="valid",
data_format="NCHW"):
super(MaxPool2d, self).__init__(kernel_size, stride, pad_mode,
data_format)
self.max_pool = P.MaxPool(kernel_size=self.kernel_size,
strides=self.stride,
pad_mode=self.pad_mode,
data_format=self.format)
def __init__(self, num_classes=10, channel=3):
super(AlexNet, self).__init__()
self.conv1 = conv(channel, 96, 11, stride=4)
self.conv2 = conv(96, 256, 5, pad_mode="same")
self.conv3 = conv(256, 384, 3, pad_mode="same")
self.conv4 = conv(384, 384, 3, pad_mode="same")
self.conv5 = conv(384, 256, 3, pad_mode="same")
self.relu = nn.ReLU()
self.max_pool2d = P.MaxPool(ksize=3, strides=2)
self.flatten = nn.Flatten()
self.fc1 = fc_with_initialize(6*6*256, 4096)
self.fc2 = fc_with_initialize(4096, 4096)
self.fc3 = fc_with_initialize(4096, num_classes)
def __init__(self, kernel_size=1, stride=1, pad_mode="valid"):
super(MaxPool1d, self).__init__(kernel_size, stride, pad_mode)
validator.check_value_type('kernel_size', kernel_size, [int], self.cls_name)
validator.check_value_type('stride', stride, [int], self.cls_name)
self.pad_mode = validator.check_string(pad_mode.upper(), ['VALID', 'SAME'], 'pad_mode', self.cls_name)
validator.check_int(kernel_size, 1, Rel.GE, "kernel_size", self.cls_name)
validator.check_int(stride, 1, Rel.GE, "stride", self.cls_name)
self.kernel_size = (1, kernel_size)
self.stride = (1, stride)
self.max_pool = P.MaxPool(ksize=self.kernel_size,
strides=self.stride,
padding=self.pad_mode)
self.shape = F.shape
self.reduce_mean = P.ReduceMean(keep_dims=True)
self.expand = P.ExpandDims()
self.squeeze = P.Squeeze(2)
def __init__(self, kernel_size=1, stride=1, pad_mode="VALID", padding=0):
max_pool = P.MaxPool(ksize=kernel_size,
strides=stride,
padding=pad_mode)
self.is_autodiff_backend = False
if self.is_autodiff_backend:
# At present, pad mode of max pool is not unified, so it is a temporarily avoided
pad_mode = validator.check_string('pad_mode', pad_mode.lower(),
['valid', 'same'])
max_pool = P.MaxPoolWithArgmax(window=kernel_size,
stride=stride,
pad_mode=pad_mode,
pad=padding)
super(MaxPool2d, self).__init__(kernel_size, stride, pad_mode, padding,
max_pool)
def __init__(self):
super(Net, self).__init__()
self.maxpool = P.MaxPool(pad_mode="SAME", window=3, stride=2)
def __init__(self):
super(Net, self).__init__()
self.maxpool = P.MaxPool(padding="SAME", ksize=3, strides=2)
'skip': ['backward']}),
('Elu', {
'block': P.Elu(),
'desc_inputs': [[2, 3, 4]],
'desc_bprop': [[2, 3, 4]]}),
('EluGrad', {
'block': G.EluGrad(),
'desc_inputs': [[2, 3, 4], [2, 3, 4]],
'desc_bprop': [[2, 3, 4]],
'skip': ['backward']}),
('Sigmoid', {
'block': P.Sigmoid(),
'desc_inputs': [[1, 3, 4, 4]],
'desc_bprop': [[1, 3, 4, 4]]}),
('MaxPool', {
'block': P.MaxPool(ksize=(2, 2), strides=(2, 2), padding="VALID"),
'desc_inputs': [[100, 3, 28, 28]],
'desc_bprop': [[100, 3, 14, 14]]}),
('MaxPoolGrad', {
'block': G.MaxPoolGrad(ksize=(2, 2), strides=(2, 2), padding="VALID"),
'desc_inputs': [[3, 4, 6, 6], [3, 4, 3, 3], [3, 4, 3, 3]],
'desc_bprop': [[3, 4, 6, 6]],
'skip': ['backward']}),
('AvgPool', {
'block': P.AvgPool(ksize=(2, 2), strides=(2, 2), padding="VALID"),
'desc_inputs': [[100, 3, 28, 28]],
'desc_bprop': [[100, 3, 14, 14]]}),
('AvgPoolGrad', {
'block': G.AvgPoolGrad(ksize=(2, 2), strides=(2, 2), padding="VALID"),
'desc_const': [(3, 4, 6, 6)],
'const_first': True,
def __init__(self):
super(Net, self).__init__()
self.maxpool = P.MaxPool(pad_mode="SAME", kernel_size=3, strides=2)
'desc_inputs': [Tensor(np.ones([1, 1, 32]).astype(np.float32))],
'skip': ['backward']
}),
# kernel size is invalid(very large)
('MaxPoolWithArgmax3', {
'block': (P.MaxPoolWithArgmax(ksize=50), {
'exception': ValueError,
'error_keywords': ['MaxPoolWithArgmax']
}),
'desc_inputs': [Tensor(np.ones([1, 1, 32, 32]).astype(np.float32))],
'skip': ['backward']
}),
# input is scalar
('MaxPool0', {
'block': (P.MaxPool(), {
'exception': TypeError,
'error_keywords': ['MaxPool']
}),
'desc_inputs': [5.0],
'skip': ['backward']
}),
# rank of x is not 4
('MaxPool1', {
'block': (P.MaxPool(), {
'exception': ValueError,
'error_keywords': ['MaxPool']
}),
'desc_inputs': [Tensor(np.ones([1, 1, 32]).astype(np.float32))],
'skip': ['backward']
}),