def __init__(self):
super(LeNet5, self).__init__()
self.batch_size = 32
self.conv1 = conv(1, 6, 5)
self.conv2 = conv(6, 16, 5)
self.fc1 = fc_with_initialize(16 * 5 * 5, 120)
self.fc2 = fc_with_initialize(120, 84)
self.fc3 = fc_with_initialize(84, 10)
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
self.reshape = P.Reshape()
def __init__(self):
super().__init__()
self.relu = nn.ReLU()
self.mul = P.Mul()
self.add = P.Add()
self.sub = P.Sub()
self.assign = P.Assign()
param_a = np.full((1, ), 5, dtype=np.float32)
self.param_a = Parameter(Tensor(param_a), name='a')
param_b = np.full((1, ), 2, dtype=np.float32)
self.param_b = Parameter(Tensor(param_b), name='b')
def __init__(self, cin, cout):
super(DeformConv, self).__init__()
self.actf = nn.SequentialCell(
[nn.BatchNorm2d(cout, momentum=BN_MOMENTUM),
nn.ReLU()])
self.conv = DCN(cin,
cout,
kernel_size=3,
stride=1,
padding=1,
modulation=True)
def __init__(self, in_channels, out_channels, use_batch_statistics=True):
super(ASPPPooling, self).__init__()
self.conv = nn.SequentialCell([
nn.Conv2d(in_channels,
out_channels,
kernel_size=1,
weight_init='xavier_uniform'),
nn.BatchNorm2d(out_channels,
use_batch_statistics=use_batch_statistics),
nn.ReLU()
])
self.shape = P.Shape()
def __init__(self, matmul_0_weight_shape, add_1_bias_shape):
"""init function"""
super(Module15, self).__init__()
self.matmul_0 = nn.MatMul()
self.matmul_0_w = Parameter(Tensor(
np.random.uniform(0, 1, matmul_0_weight_shape).astype(np.float32)),
name=None)
self.add_1 = P.Add()
self.add_1_bias = Parameter(Tensor(
np.random.uniform(0, 1, add_1_bias_shape).astype(np.float32)),
name=None)
self.relu_2 = nn.ReLU()
def __init__(self, linear_weight_shape, linear_bias_shape):
"""init function"""
super(Linear, self).__init__()
self.matmul = nn.MatMul()
self.matmul_w = Parameter(Tensor(
np.random.uniform(0, 1, linear_weight_shape).astype(np.float32)),
name=None)
self.add = P.Add()
self.add_bias = Parameter(Tensor(
np.random.uniform(0, 1, linear_bias_shape).astype(np.float32)),
name=None)
self.relu = nn.ReLU()
def __init__(self):
super(Net, self).__init__()
self.conv = nn.Conv2d(3,
64,
3,
has_bias=False,
weight_init='normal',
pad_mode='valid')
self.bn = nn.BatchNorm2d(64)
self.relu = nn.ReLU()
self.flatten = nn.Flatten()
self.fc = nn.Dense(64 * 222 * 222, 3) # padding=0
def __init__(self, inplanes, squeeze_planes, expand1x1_planes,
expand3x3_planes):
super(Fire, self).__init__()
self.inplanes = inplanes
self.squeeze = nn.Conv2d(inplanes,
squeeze_planes,
kernel_size=1,
has_bias=True)
self.squeeze_activation = nn.ReLU()
self.expand1x1 = nn.Conv2d(squeeze_planes,
expand1x1_planes,
kernel_size=1,
has_bias=True)
self.expand1x1_activation = nn.ReLU()
self.expand3x3 = nn.Conv2d(squeeze_planes,
expand3x3_planes,
kernel_size=3,
pad_mode='same',
has_bias=True)
self.expand3x3_activation = nn.ReLU()
self.concat = P.Concat(axis=1)
def __init__(self, base, num_classes=1000, batch_norm=False, batch_size=1, args=None, phase="train",
include_top=True):
super(Vgg, self).__init__()
_ = batch_size
self.layers = _make_layer(base, args, batch_norm=batch_norm)
self.include_top = include_top
self.flatten = nn.Flatten()
dropout_ratio = 0.5
if not args.has_dropout or phase == "test":
dropout_ratio = 1.0
self.classifier = nn.SequentialCell([
nn.Dense(512 * 7 * 7, 4096),
nn.ReLU(),
nn.Dropout(dropout_ratio),
nn.Dense(4096, 4096),
nn.ReLU(),
nn.Dropout(dropout_ratio),
nn.Dense(4096, num_classes)])
if args.initialize_mode == "KaimingNormal":
default_recurisive_init(self)
self.custom_init_weight()
def _make_layer(self, cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if v == 'M':
layers += [
nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='same')
]
else:
conv2d = Conv2d(in_channels=in_channels,
out_channels=v,
kernel_size=3,
stride=1,
pad_mode='same',
has_bias=True)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU()]
else:
layers += [conv2d, nn.ReLU()]
in_channels = v
return nn.SequentialCell(layers)
def __init__(self, num_input_features, num_output_features, avgpool=False):
super(_Transition, self).__init__()
if avgpool:
poollayer = nn.AvgPool2d(kernel_size=2, stride=2)
else:
poollayer = nn.MaxPool2d(kernel_size=2, stride=2)
self.features = nn.SequentialCell(
OrderedDict([('norm', nn.BatchNorm2d(num_input_features)),
('relu', nn.ReLU()),
('conv',
conv1x1(num_input_features, num_output_features)),
('pool', poollayer)]))
def __init__(self):
super(Net, self).__init__()
self.weight = Parameter(Tensor(
np.ones([64, 10]).astype(np.float32)),
name="weight")
self.bias = Parameter(Tensor(np.ones([10]).astype(np.float32)),
name="bias")
self.fc = P.MatMul()
self.fc2 = nn.Dense(10, 10)
self.biasAdd = P.BiasAdd()
self.relu = nn.ReLU()
self.cast = P.Cast()
def __init__(self, num_class=10):
super(LeNet5, self).__init__()
self.num_class = num_class
self.batch_size = 32
self.conv1 = conv(1, 6, 5)
self.conv2 = conv(6, 16, 5)
self.fc1 = fc_with_initialize(16 * 5 * 5, 120)
self.fc2 = fc_with_initialize(120, 84)
self.fc3 = fc_with_initialize(84, self.num_class)
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
self.flatten = nn.Flatten()
def __init__(self, num_class=15, num_channel=1, include_top=True):
super(LeNet5, self).__init__()
self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
self.include_top = include_top
if self.include_top:
self.flatten = nn.Flatten()
self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
def __init__(self,
in_channel,
out_channel,
stride=1,
damping=0.03,
loss_scale=1,
frequency=278):
super(ResidualBlock, self).__init__()
channel = out_channel // self.expansion
self.conv1 = _conv1x1(in_channel,
channel,
stride=1,
damping=damping,
loss_scale=loss_scale,
frequency=frequency)
self.bn1 = _bn(channel)
self.conv2 = _conv3x3(channel,
channel,
stride=stride,
damping=damping,
loss_scale=loss_scale,
frequency=frequency)
self.bn2 = _bn(channel)
self.conv3 = _conv1x1(channel,
out_channel,
stride=1,
damping=damping,
loss_scale=loss_scale,
frequency=frequency)
self.bn3 = _bn_last(out_channel)
self.relu = nn.ReLU()
self.down_sample = False
if stride != 1 or in_channel != out_channel:
self.down_sample = True
self.down_sample_layer = None
if self.down_sample:
self.down_sample_layer = nn.SequentialCell([
_conv1x1(in_channel,
out_channel,
stride,
damping=damping,
loss_scale=loss_scale,
frequency=frequency),
_bn(out_channel)
])
self.add = P.TensorAdd()
def __init__(self, num_class=10):
super(BNNLeNet5, self).__init__()
self.num_class = num_class
self.conv1 = bnn_layers.ConvReparam(1, 6, 5, stride=1, padding=0, has_bias=False, pad_mode="valid")
self.conv2 = conv(6, 16, 5)
self.fc1 = bnn_layers.DenseReparam(16 * 5 * 5, 120)
self.fc2 = fc_with_initialize(120, 84)
self.fc3 = fc_with_initialize(84, self.num_class)
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
self.flatten = nn.Flatten()
self.reshape = P.Reshape()
def __init__(self, in_channels, out_channels, bilinear=True):
super().__init__()
self.concat = F.Concat(axis=1)
self.factor = 56.0 / 64.0
self.center_crop = CentralCrop(central_fraction=self.factor)
self.print_fn = F.Print()
self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
self.up = nn.Conv2dTranspose(in_channels,
in_channels // 2,
kernel_size=2,
stride=2)
self.relu = nn.ReLU()
def __init__(self, act_func):
super(Activation, self).__init__()
if act_func == 'relu':
self.act = nn.ReLU()
elif act_func == 'relu6':
self.act = nn.ReLU6()
elif act_func in ('hsigmoid', 'hard_sigmoid'):
self.act = MyHSigmoid() # nn.HSigmoid()
elif act_func in ('hswish', 'hard_swish'):
self.act = nn.HSwish()
else:
raise NotImplementedError
def __init__(self,
in_channels,
out_channels,
stride=1,
use_batch_statistics=False,
use_batch_to_stob_and_btos=False):
super(BottleneckV1, self).__init__()
expansion = 4
mid_channels = out_channels // expansion
self.conv_bn1 = _conv_bn_relu(in_channels,
mid_channels,
ksize=1,
stride=1,
use_batch_statistics=use_batch_statistics)
self.conv_bn2 = _conv_bn_relu(mid_channels,
mid_channels,
ksize=3,
stride=stride,
padding=1,
dilation=1,
use_batch_statistics=use_batch_statistics)
if use_batch_to_stob_and_btos:
self.conv_bn2 = _stob_conv_btos_bn_relu(mid_channels,
mid_channels,
ksize=3,
stride=stride,
padding=0,
dilation=1,
space_to_batch_block_shape=2,
batch_to_space_block_shape=2,
paddings=[[2, 3], [2, 3]],
crops=[[0, 1], [0, 1]],
pad_mode="valid",
use_batch_statistics=use_batch_statistics)
self.conv3 = nn.Conv2d(mid_channels,
out_channels,
kernel_size=1,
stride=1)
self.bn3 = nn.BatchNorm2d(out_channels, use_batch_statistics=use_batch_statistics)
if in_channels != out_channels:
conv = nn.Conv2d(in_channels,
out_channels,
kernel_size=1,
stride=stride)
bn = nn.BatchNorm2d(out_channels, use_batch_statistics=use_batch_statistics)
self.downsample = nn.SequentialCell([conv, bn])
else:
self.downsample = Subsample(stride)
self.add = P.TensorAdd()
self.relu = nn.ReLU()
self.Reshape = P.Reshape()
def __init__(self, num_class=10, channel=1):
super(LeNet5, self).__init__()
self.num_class = num_class
self.conv1 = nn.Conv2d(channel, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Dense(16 * 5 * 5, 120)
self.fc2 = nn.Dense(120, 84)
self.fc3 = nn.Dense(84, self.num_class)
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
self.flatten = nn.Flatten()
def test_model_build_abnormal_string():
""" test_model_build_abnormal_string """
net = nn.ReLU()
context.set_context(mode=context.GRAPH_MODE)
model = Model(net)
err = False
try:
model.predict('aaa')
except ValueError as e:
log.error("Find value error: %r ", e)
err = True
finally:
assert err
def __init__(self, num_classes=10):
super(DefinedNet, self).__init__()
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=0,
weight_init="zeros")
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU()
self.maxpool = P.MaxPoolWithArgmax(padding="same", ksize=2, strides=2)
self.flatten = nn.Flatten()
self.fc = nn.Dense(int(56 * 56 * 64), num_classes)
def Act(type='default'):
if type in ['default', 'def']:
return Act(DEFAULTS['activation'])
if type == 'relu':
return nn.ReLU()
elif type == 'sigmoid':
return nn.Sigmoid()
elif type == 'hswish':
return nn.HSwish()
elif type == 'leaky_relu':
return nn.LeakyReLU(alpha=DEFAULTS['leaky_relu']['alpha'])
else:
raise ValueError("Unsupported activation type: %s" % type)
def __init__(self, num_class=10, num_channel=3, count=0):
super(myNN, self).__init__()
self.conv1 = nn.Conv2d(num_channel, 16, 5, pad_mode='valid')
self.conv2 = nn.Conv2d(16, 32, 5)
self.fc1 = nn.Dense(3872, 128, weight_init=Normal(0.02))
self.fc2 = nn.Dense(128, 64, weight_init=Normal(0.02))
self.fc3 = nn.Dense(64, num_class, weight_init=Normal(0.02))
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
self.flatten = nn.Flatten()
self.dropout = nn.Dropout(keep_prob=0.9)
def __init__(self, in_channel, out_channel):
super(TestUserDefinedBpropNet, self).__init__()
self.relu = nn.ReLU()
self.conv = nn.Conv2d(in_channels=in_channel,
out_channels=out_channel,
kernel_size=2,
stride=1,
has_bias=False,
weight_init='ones',
pad_mode='same')
self.crop = CropAndResizeNet((10, 10))
self.boxes = Tensor(np.ones((128, 4)).astype(np.float32))
self.box_indices = Tensor(np.ones((128, )).astype(np.int32))
def __init__(self, num_classes=10):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=0,
weight_init="zeros")
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU()
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2)
self.flatten = nn.Flatten()
self.fc = nn.Dense(int(224 * 224 * 64 / 16), num_classes)
def __init__(self, in_channels, out_channels, mid_channels=None):
super().__init__()
init_value_0 = TruncatedNormal(0.06)
init_value_1 = TruncatedNormal(0.06)
if not mid_channels:
mid_channels = out_channels
self.double_conv = nn.SequentialCell([
nn.Conv2d(in_channels,
mid_channels,
kernel_size=3,
has_bias=True,
weight_init=init_value_0,
pad_mode="valid"),
nn.ReLU(),
nn.Conv2d(mid_channels,
out_channels,
kernel_size=3,
has_bias=True,
weight_init=init_value_1,
pad_mode="valid"),
nn.ReLU()
])
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):
super(LossNet, self).__init__()
self.conv = nn.Conv2d(3,
64,
3,
has_bias=False,
weight_init='normal',
pad_mode='valid')
self.bn = nn.BatchNorm2d(64)
self.relu = nn.ReLU()
self.flatten = nn.Flatten()
self.fc = nn.Dense(64 * 222 * 222, 3) # padding=0
self.loss = nn.SoftmaxCrossEntropyWithLogits()
def __init__(self,
growth_rate,
block_config,
num_init_features,
bn_size=4,
drop_rate=0):
super(Densenet, self).__init__()
layers = OrderedDict()
layers['conv0'] = conv7x7(3, num_init_features, stride=2, padding=3)
layers['norm0'] = nn.BatchNorm2d(num_init_features)
layers['relu0'] = nn.ReLU()
layers['pool0'] = nn.MaxPool2d(kernel_size=3,
stride=2,
pad_mode='same')
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
layers['denseblock%d' % (i + 1)] = block
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
layers['transition%d' % (i + 1)] = trans
num_features = num_features // 2
# Final batch norm
layers['norm5'] = nn.BatchNorm2d(num_features)
layers['relu5'] = nn.ReLU()
self.features = nn.SequentialCell(layers)
self.out_channels = num_features