def __init__(self):
super(LeNet5, self).__init__()
self.conv1 = nn.Conv2d(1, 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, 10)
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2)
self.flatten = P.Flatten()
def __init__(self):
super(NetMissConstruct, self).__init__()
self.conv1 = nn.Conv2d(1, 6, 5, pad_mode='valid')
self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
self.fc1 = nn.Dense(16 * 5 * 5, 120)
self.fc2 = nn.Dense(120, 84)
self.fc3 = nn.Dense(84, 10)
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2)
self.flatten = P.Flatten()
def __init__(self):
super(Conv2dNativeNet, self).__init__()
self.conv = P.DepthwiseConv2dNative(channel_multiplier=3, kernel_size=(3, 3))
self.flatten = P.Flatten()
channel_multipliers = 1
in_channels = 3
kernel_size = (3, 3)
self.weight = Parameter(initializer(
Tensor(np.ones([channel_multipliers, in_channels, *kernel_size], dtype=np.float32)),
[channel_multipliers, in_channels, *kernel_size]), name='weight')
def __init__(self):
super(BlockNet, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, pad_mode="pad", padding=3)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU()
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2)
self.block_down_sample = ResidualBlock(
64, 256, stride=1, down_sample=True
)
self.flatten = P.Flatten()
self.weight = Parameter(Tensor(np.ones([1024, 10]).astype(np.float32)), name="weight")
self.bias = Parameter(Tensor(np.ones([10]).astype((np.float32))), name="bias")
self.fc = P.MatMul()
self.biasAdd = P.BiasAdd()
def __init__(self, config):
super(TransformerTrainingLoss, self).__init__(auto_prefix=False)
self.vocab_size = config.vocab_size
self.onehot = P.OneHot()
self.on_value = Tensor(float(1 - config.label_smoothing), mstype.float32)
self.off_value = Tensor(config.label_smoothing / float(self.vocab_size - 1), mstype.float32)
self.reduce_sum = P.ReduceSum()
self.reduce_mean = P.ReduceMean()
self.reshape = P.Reshape()
self.last_idx = (-1,)
self.flatten = P.Flatten()
self.neg = P.Neg()
self.cast = P.Cast()
self.flat_shape = (config.batch_size * config.seq_length,)
def __init__(self):
super(BatchnormNet, self).__init__()
self.conv1 = nn.Conv2d(3,
4,
kernel_size=8,
stride=2,
pad_mode="pad",
padding=3)
self.bn1 = nn.BatchNorm2d(4)
self.flatten = P.Flatten()
self.weight = Parameter(Tensor(np.ones([64, 10], np.float32)),
name="weight")
self.bias = Parameter(Tensor(np.ones([10], np.float32)), name="bias")
self.fc = P.MatMul()
self.biasAdd = P.BiasAdd()
def __init__(self, config):
super(LabelSmoothedCrossEntropyCriterion, self).__init__()
self.vocab_size = config.vocab_size
self.onehot = P.OneHot()
self.on_value = Tensor(float(1 - config.label_smoothing), mstype.float32)
self.off_value = Tensor(config.label_smoothing / float(self.vocab_size - 1), mstype.float32)
self.reduce_sum = P.ReduceSum()
self.reduce_mean = P.ReduceMean()
self.reshape = P.Reshape()
self.last_idx = (-1,)
self.flatten = P.Flatten()
self.neg = P.Neg()
self.cast = P.Cast()
self.flat_shape = (config.batch_size * config.seq_length,)
self.get_shape = P.Shape()
def __init__(self, model_cfgs, num_classes=1000, multiplier=1., final_drop=0., round_nearest=8):
super(GhostNet, self).__init__()
self.cfgs = model_cfgs['cfg']
self.inplanes = 16
first_conv_in_channel = 3
first_conv_out_channel = _make_divisible(multiplier * self.inplanes)
self.conv_stem = nn.Conv2d(in_channels=first_conv_in_channel,
out_channels=first_conv_out_channel,
kernel_size=3, padding=1, stride=2,
has_bias=False, pad_mode='pad')
self.bn1 = nn.BatchNorm2d(first_conv_out_channel)
self.act1 = Activation('relu')
self.blocks = []
for layer_cfg in self.cfgs:
self.blocks.append(self._make_layer(kernel_size=layer_cfg[0],
exp_ch=_make_divisible(
multiplier * layer_cfg[1]),
out_channel=_make_divisible(
multiplier * layer_cfg[2]),
use_se=layer_cfg[3],
act_func=layer_cfg[4],
stride=layer_cfg[5]))
output_channel = _make_divisible(
multiplier * model_cfgs["cls_ch_squeeze"])
self.blocks.append(ConvUnit(_make_divisible(multiplier * self.cfgs[-1][2]), output_channel,
kernel_size=1, stride=1, padding=0, num_groups=1, use_act=True))
self.blocks = nn.SequentialCell(self.blocks)
self.global_pool = GlobalAvgPooling(keep_dims=True)
self.conv_head = nn.Conv2d(in_channels=output_channel,
out_channels=model_cfgs['cls_ch_expand'],
kernel_size=1, padding=0, stride=1,
has_bias=True, pad_mode='pad')
self.act2 = Activation('relu')
self.squeeze = P.Flatten()
self.final_drop = final_drop
if self.final_drop > 0:
self.dropout = nn.Dropout(self.final_drop)
self.classifier = nn.Dense(
model_cfgs['cls_ch_expand'], num_classes, has_bias=True)
self._initialize_weights()
def __init__(self, input_channels, output_channels, num_classes, pool_size):
super(FpnCls, self).__init__()
representation_size = input_channels * pool_size * pool_size
shape_0 = (output_channels, representation_size)
weights_0 = initializer("XavierUniform", shape=shape_0[::-1], dtype=mstype.float32)
shape_1 = (output_channels, output_channels)
weights_1 = initializer("XavierUniform", shape=shape_1[::-1], dtype=mstype.float32)
self.shared_fc_0 = DenseNoTranpose(representation_size, output_channels, weights_0).to_float(mstype.float16)
self.shared_fc_1 = DenseNoTranpose(output_channels, output_channels, weights_1).to_float(mstype.float16)
cls_weight = initializer('Normal', shape=[num_classes, output_channels][::-1],
dtype=mstype.float32)
reg_weight = initializer('Normal', shape=[num_classes * 4, output_channels][::-1],
dtype=mstype.float32)
self.cls_scores = DenseNoTranpose(output_channels, num_classes, cls_weight).to_float(mstype.float16)
self.reg_scores = DenseNoTranpose(output_channels, num_classes * 4, reg_weight).to_float(mstype.float16)
self.relu = P.ReLU()
self.flatten = P.Flatten()
def __init__(self, block, num_classes=100):
super(ResNet50, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, pad_mode='pad')
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU()
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, pad_mode='valid')
self.layer1 = self.MakeLayer(
block, 3, in_channels=64, out_channels=256, stride=1)
self.layer2 = self.MakeLayer(
block, 4, in_channels=256, out_channels=512, stride=2)
self.layer3 = self.MakeLayer(
block, 6, in_channels=512, out_channels=1024, stride=2)
self.layer4 = self.MakeLayer(
block, 3, in_channels=1024, out_channels=2048, stride=2)
self.avgpool = nn.AvgPool2d(7, 1)
self.flatten = P.Flatten()
self.fc = nn.Dense(512 * block.expansion, num_classes)
def __init__(self):
super(FlattenNet, self).__init__()
self.flatten = P.Flatten()
def __init__(self):
super(Conv2dWithBiasNet, self).__init__()
self.conv = nn.Conv2d(3, 10, 1, bias_init='zeros')
self.flatten = P.Flatten()
class TopKNet(nn.Cell):
def __init__(self, net, k):
super(TopKNet, self).__init__()
self.net = net
self.k = k
def construct(self, x):
return self.net(x, self.k)
raise_set = [
# input is scalar
('Flatten0', {
'block': (P.Flatten(), {
'exception': TypeError,
'error_keywords': ['Flatten']
}),
'desc_inputs': [5.0],
'skip': ['backward']
}),
# dim of input is zero
('Flatten1', {
'block': (P.Flatten(), {
'exception': ValueError,
'error_keywords': ['Flatten']
}),
'desc_inputs': [F.scalar_to_tensor(5.0)],
'skip': ['backward']
}),
def __init__(self,
config,
representation_size,
batch_size,
num_classes,
target_means=(0., 0., 0., 0.),
target_stds=(0.1, 0.1, 0.2, 0.2)):
super(Rcnn, self).__init__()
cfg = config
self.rcnn_loss_cls_weight = Tensor(
np.array(cfg.rcnn_loss_cls_weight).astype(np.float16))
self.rcnn_loss_reg_weight = Tensor(
np.array(cfg.rcnn_loss_reg_weight).astype(np.float16))
self.rcnn_fc_out_channels = cfg.rcnn_fc_out_channels
self.target_means = target_means
self.target_stds = target_stds
self.num_classes = num_classes
self.in_channels = cfg.rcnn_in_channels
self.train_batch_size = batch_size
self.test_batch_size = cfg.test_batch_size
self.use_ambigous_sample = cfg.use_ambigous_sample
shape_0 = (self.rcnn_fc_out_channels, representation_size)
weights_0 = initializer("XavierUniform",
shape=shape_0[::-1],
dtype=mstype.float16).to_tensor()
shape_1 = (self.rcnn_fc_out_channels, self.rcnn_fc_out_channels)
weights_1 = initializer("XavierUniform",
shape=shape_1[::-1],
dtype=mstype.float16).to_tensor()
self.shared_fc_0 = DenseNoTranpose(representation_size,
self.rcnn_fc_out_channels,
weights_0)
self.shared_fc_1 = DenseNoTranpose(self.rcnn_fc_out_channels,
self.rcnn_fc_out_channels,
weights_1)
cls_weight = initializer(
'Normal',
shape=[num_classes, self.rcnn_fc_out_channels][::-1],
dtype=mstype.float16).to_tensor()
reg_weight = initializer(
'Normal',
shape=[num_classes * 4, self.rcnn_fc_out_channels][::-1],
dtype=mstype.float16).to_tensor()
self.cls_scores = DenseNoTranpose(self.rcnn_fc_out_channels,
num_classes, cls_weight)
self.reg_scores = DenseNoTranpose(self.rcnn_fc_out_channels,
num_classes * 4, reg_weight)
self.flatten = P.Flatten()
self.relu = P.ReLU()
self.logicaland = P.LogicalAnd()
self.loss_cls = P.SoftmaxCrossEntropyWithLogits()
self.loss_bbox = P.SmoothL1Loss(beta=1.0)
self.reshape = P.Reshape()
self.onehot = P.OneHot()
self.greater = P.Greater()
self.equal = P.Equal()
self.cast = P.Cast()
self.sum_loss = P.ReduceSum()
self.tile = P.Tile()
self.expandims = P.ExpandDims()
self.gather = P.GatherNd()
self.argmax = P.ArgMaxWithValue(axis=1)
self.on_value = Tensor(1.0, mstype.float32)
self.off_value = Tensor(0.0, mstype.float32)
self.value = Tensor(1.0, mstype.float16)
self.num_bboxes = (cfg.num_expected_pos_stage2 +
cfg.num_expected_neg_stage2) * batch_size
if self.use_ambigous_sample:
self.num_bboxes = (cfg.num_expected_pos_stage2 +
cfg.num_expected_amb_stage2 +
cfg.num_expected_neg_stage2) * batch_size
rmv_first = np.ones((self.num_bboxes, self.num_classes))
rmv_first[:, 0] = np.zeros((self.num_bboxes, ))
self.rmv_first_tensor = Tensor(rmv_first.astype(np.float16))
self.num_bboxes_test = cfg.rpn_max_num * cfg.test_batch_size
range_max = np.arange(self.num_bboxes_test).astype(np.int32)
self.range_max = Tensor(range_max)
def __init__(self):
super(NetForFlatten0D, self).__init__()
self.flatten = P.Flatten()
'desc_const': [(3, 4, 6, 6)],
'const_first': True,
'desc_inputs': [[3, 4, 6, 6]],
'desc_bprop': [[3, 4, 6, 6]],
'skip': ['backward']}),
('MaxPoolWithArgmax', {
'block': P.MaxPoolWithArgmax(ksize=2, strides=2),
'desc_inputs': [[128, 32, 32, 64]],
'desc_bprop': [[128, 32, 8, 16], [128, 32, 8, 16]]}),
('SoftmaxCrossEntropyWithLogits', {
'block': P.SoftmaxCrossEntropyWithLogits(),
'desc_inputs': [[1, 10], [1, 10]],
'desc_bprop': [[1], [1, 10]],
'skip': ['backward_exec']}),
('Flatten', {
'block': P.Flatten(),
'desc_inputs': [[128, 32, 32, 64]],
'desc_bprop': [[128 * 32 * 8 * 16]]}),
('LogSoftmax', {
'block': P.LogSoftmax(),
'desc_inputs': [[64, 2]],
'desc_bprop': [[160, 30522]]}),
('LogSoftmaxGrad', {
'block': G.LogSoftmaxGrad(),
'desc_inputs': [[16, 1234], [16, 1234]],
'desc_bprop': [[64, 2]],
'skip': ['backward']}),
('LayerNorm', {
'block': P.LayerNorm(),
'desc_inputs': [[2, 16], [16], [16]],
'desc_bprop': [[2, 16], [2, 16], [2, 16]]}),
def __init__(self, num_classes=10, dropout_keep_prob=0.8):
super(Logits, self).__init__()
self.avg_pool = nn.AvgPool2d(8, pad_mode='valid')
self.dropout = nn.Dropout(keep_prob=dropout_keep_prob)
self.flatten = P.Flatten()
self.fc = nn.Dense(2048, num_classes)
def __init__(self):
super(NetLastFlatten, self).__init__()
self.flatten = P.Flatten()
self.relu = P.ReLU()
def __init__(self):
super(NetAllFlatten, self).__init__()
self.flatten = P.Flatten()
def __init__(self, symbol, loop_count=(1, 3)):
super().__init__()
self.symbol = symbol
self.loop_count = loop_count
self.fla = P.Flatten()
self.relu = ReLU()