def __init__(self, batch_size): """init function""" super(Reader_Albert, self).__init__() self.expanddims_0 = P.ExpandDims() self.expanddims_0_axis = 1 self.expanddims_3 = P.ExpandDims() self.expanddims_3_axis = 2 self.cast_5 = P.Cast() self.cast_5_to = mstype.float32 self.sub_7 = P.Sub() self.sub_7_bias = 1.0 self.mul_9 = P.Mul() self.mul_9_w = -10000.0 self.gather_1_input_weight = Parameter(Tensor(np.random.uniform(0, 1, (30005, 128)).astype(np.float32)), name=None) self.gather_1_axis = 0 self.gather_1 = P.Gather() self.gather_2_input_weight = Parameter(Tensor(np.random.uniform(0, 1, (2, 128)).astype(np.float32)), name=None) self.gather_2_axis = 0 self.gather_2 = P.Gather() self.add_4 = P.Add() self.add_6 = P.Add() self.add_6_bias = Parameter(Tensor(np.random.uniform(0, 1, (1, 512, 128)).astype(np.float32)), name=None) self.layernorm1_0 = LayerNorm(mul_7_w_shape=(128,), add_8_bias_shape=(128,)) self.linear3_0 = Linear(matmul_0_weight_shape=(128, 4096), add_1_bias_shape=(4096,)) self.module34_0 = TransformerLayer(batch_size, layernorm1_0_mul_7_w_shape=(4096,), layernorm1_0_add_8_bias_shape=(4096,), linear3_0_matmul_0_weight_shape=(4096, 16384), linear3_0_add_1_bias_shape=(16384,), linear3_1_matmul_0_weight_shape=(16384, 4096), linear3_1_add_1_bias_shape=(4096,)) self.layernorm1_1 = LayerNorm(mul_7_w_shape=(4096,), add_8_bias_shape=(4096,))
def __init__(self, strategy_dict=None): super().__init__() shared_np = np.full((16, 1, 32, 32), 0.5, dtype=np.float32) self.shared_weight = Parameter(Tensor(shared_np), name='shared_weight') self.fc1 = Dense(in_channels=1024, out_channels=116, weight_init='ones', bias_init='ones', has_bias=True) self.relu = ReLU() self.sigmoid = P.Sigmoid() self.add1 = P.Add() self.add2 = P.Add() self.mul1 = P.Mul().add_prim_attr('primitive_target', 'CPU') self.mul2 = P.Mul() self.mul3 = P.Mul() self.flatten = Flatten() mul2_weight_np = np.full((16, 116), 1, dtype=np.float32) self.mul2_weight = Parameter(Tensor(mul2_weight_np), name='mul2_weight') mul3_weight_np = np.full((16, 116), 1, dtype=np.float32) self.mul3_weight = Parameter(Tensor(mul3_weight_np), name='mul3_weight') if strategy_dict is not None: self.add1.shard(strategy_dict['add1']) self.mul1.shard(strategy_dict['mul1']) self.fc1.matmul.shard(strategy_dict['fc1_matmul']) self.fc1.bias_add.shard(strategy_dict['fc1_bias_add']) self.mul2.shard(strategy_dict['mul2']) self.mul3.shard(strategy_dict['mul3'])
def __init__(self): """init function""" super(Rerank_Downstream, self).__init__() self.dense_0 = nn.Dense(in_channels=4096, out_channels=8192, has_bias=True) self.relu_1 = nn.ReLU() self.reducemean_2 = P.ReduceMean(keep_dims=True) self.sub_3 = P.Sub() self.sub_4 = P.Sub() self.pow_5 = P.Pow() self.pow_5_input_weight = 2.0 self.reducemean_6 = P.ReduceMean(keep_dims=True) self.add_7 = P.Add() self.add_7_bias = 9.999999960041972e-13 self.sqrt_8 = P.Sqrt() self.div_9 = P.Div() self.mul_10 = P.Mul() self.mul_10_w = Parameter(Tensor( np.random.uniform(0, 1, (8192, )).astype(np.float32)), name=None) self.add_11 = P.Add() self.add_11_bias = Parameter(Tensor( np.random.uniform(0, 1, (8192, )).astype(np.float32)), name=None) self.dense_12 = nn.Dense(in_channels=8192, out_channels=2, has_bias=True)
def __init__(self): super(MultiHeadAttn, self).__init__() self.matmul_0 = nn.MatMul() self.matmul_0.to_float(mstype.float16) self.matmul_0_w = Parameter(Tensor( np.random.uniform(0, 1, (768, 768)).astype(np.float32)), name=None) self.matmul_1 = nn.MatMul() self.matmul_1.to_float(mstype.float16) self.matmul_1_w = Parameter(Tensor( np.random.uniform(0, 1, (768, 768)).astype(np.float32)), name=None) self.matmul_2 = nn.MatMul() self.matmul_2.to_float(mstype.float16) self.matmul_2_w = Parameter(Tensor( np.random.uniform(0, 1, (768, 768)).astype(np.float32)), name=None) self.add_3 = P.Add() self.add_3_bias = Parameter(Tensor( np.random.uniform(0, 1, (768, )).astype(np.float32)), name=None) self.add_4 = P.Add() self.add_4_bias = Parameter(Tensor( np.random.uniform(0, 1, (768, )).astype(np.float32)), name=None) self.add_5 = P.Add() self.add_5_bias = Parameter(Tensor( np.random.uniform(0, 1, (768, )).astype(np.float32)), name=None) self.reshape_6 = P.Reshape() self.reshape_6_shape = tuple([BATCH_SIZE, 448, 12, 64]) self.reshape_7 = P.Reshape() self.reshape_7_shape = tuple([BATCH_SIZE, 448, 12, 64]) self.reshape_8 = P.Reshape() self.reshape_8_shape = tuple([BATCH_SIZE, 448, 12, 64]) self.transpose_9 = P.Transpose() self.transpose_10 = P.Transpose() self.transpose_11 = P.Transpose() self.matmul_12 = nn.MatMul() self.matmul_12.to_float(mstype.float16) self.div_13 = P.Div() self.div_13_w = 8.0 self.add_14 = P.Add() self.softmax_15 = nn.Softmax(axis=3) self.matmul_16 = nn.MatMul() self.matmul_16.to_float(mstype.float16) self.transpose_17 = P.Transpose() self.reshape_18 = P.Reshape() self.reshape_18_shape = tuple([BATCH_SIZE, 448, 768]) self.matmul_19 = nn.MatMul() self.matmul_19.to_float(mstype.float16) self.matmul_19_w = Parameter(Tensor( np.random.uniform(0, 1, (768, 768)).astype(np.float32)), name=None) self.add_20 = P.Add() self.add_20_bias = Parameter(Tensor( np.random.uniform(0, 1, (768, )).astype(np.float32)), name=None)
def __init__(self): super().__init__() self.matmul = P.MatMul() self.tadd1 = P.Add() self.tadd2 = P.Add() self.weight = Parameter(Tensor( np.ones([128, 128]).astype(np.float32) * 0.01), "w", requires_grad=True)
def __init__(self, batch_size, layernorm1_0_mul_7_w_shape, layernorm1_0_add_8_bias_shape, linear3_0_matmul_0_weight_shape, linear3_0_add_1_bias_shape, linear3_1_matmul_0_weight_shape, linear3_1_add_1_bias_shape): """init function""" super(TransformerLayer, self).__init__() self.multiheadattn_0 = MultiHeadAttn(batch_size) self.add_0 = P.Add() self.layernorm1_0 = LayerNorm(mul_7_w_shape=layernorm1_0_mul_7_w_shape, add_8_bias_shape=layernorm1_0_add_8_bias_shape) self.linear3_0 = Linear(matmul_0_weight_shape=linear3_0_matmul_0_weight_shape, add_1_bias_shape=linear3_0_add_1_bias_shape) self.newgelu2_0 = NewGeLU() self.linear3_1 = Linear(matmul_0_weight_shape=linear3_1_matmul_0_weight_shape, add_1_bias_shape=linear3_1_add_1_bias_shape) self.add_1 = P.Add()
def __init__(self): super().__init__() self.block1 = get_block() self.block2 = get_block() self.relu = P.ReLU() self.add = P.Add() self.bias = Tensor(np.ones([64, 64]), dtype=ms.float32)
def __init__(self, seq_len): super(ModelOneHop, self).__init__() self.expanddims = P.ExpandDims() self.expanddims_axis_0 = 1 self.expanddims_axis_1 = 2 self.cast = P.Cast() self.cast_to = mstype.float32 self.sub = P.Sub() self.sub_bias = 1.0 self.mul = P.Mul() self.mul_w = -10000.0 self.input_weight_0 = Parameter(Tensor( np.random.uniform(0, 1, (30522, 768)).astype(np.float32)), name=None) self.gather_axis_0 = 0 self.gather = P.Gather() self.input_weight_1 = Parameter(Tensor( np.random.uniform(0, 1, (2, 768)).astype(np.float32)), name=None) self.add = P.Add() self.add_bias = Parameter(Tensor( np.random.uniform(0, 1, (1, seq_len, 768)).astype(np.float32)), name=None) self.layernorm = LayerNorm() self.encoder_layer_1_4 = BertEncoder(seq_len) self.encoder_layer_5_8 = BertEncoder(seq_len) self.encoder_layer_9_12 = BertEncoder(seq_len) self.cls_ids = Tensor(np.array(0)) self.gather_axis_1 = 1 self.dense = nn.Dense(in_channels=768, out_channels=768, has_bias=True) self.tanh = nn.Tanh()
def __init__(self): super(NetWrapper, self).__init__() self.unq = P.Unique() self.add = P.Add() self.expand_dims = P.ExpandDims() self.cast = P.Cast() self.net = SparseApplyFtrlNet()
def __init__(self, inp, oup, stride, expand_ratio, last_relu=False): super(InvertedResidual, self).__init__() assert stride in [1, 2] hidden_dim = int(round(inp * expand_ratio)) self.use_res_connect = stride == 1 and inp == oup layers = [] if expand_ratio != 1: layers.append(ConvBNReLU(inp, hidden_dim, kernel_size=1)) layers.extend([ # dw ConvBNReLU(hidden_dim, hidden_dim, stride=stride, groups=hidden_dim), # pw-linear nn.Conv2d(hidden_dim, oup, kernel_size=1, stride=1, has_bias=False), _bn(oup), ]) self.conv = nn.SequentialCell(layers) self.add = P.Add() self.cast = P.Cast() self.last_relu = last_relu self.relu = nn.ReLU6()
def __init__(self, in_channels, out_channels, weight_init='normal', bias_init='zeros', damping=0.03, loss_scale=1, frequency=278, batch_size=32, has_bias=True, activation=None): super(Dense_Thor_GPU, self).__init__() self.in_channels = Validator.check_positive_int(in_channels) self.out_channels = Validator.check_positive_int(out_channels) self.has_bias = Validator.check_bool(has_bias) self.thor = True if isinstance(weight_init, Tensor): if weight_init.ndim != 2 or weight_init.shape[0] != out_channels or \ weight_init.shape[1] != in_channels: raise ValueError("weight_init shape error") self.weight = Parameter(initializer(weight_init, [out_channels, in_channels])) if self.has_bias: if isinstance(bias_init, Tensor): if bias_init.ndim != 1 or bias_init.shape[0] != out_channels: raise ValueError("bias_init shape error") self.bias = Parameter(initializer(bias_init, [out_channels])) self.matmul = P.MatMul(transpose_b=True) self.bias_add = P.BiasAdd() self.activation = get_activation(activation) self.activation_flag = self.activation is not None split_dim = 128 matrix_A_shape, matrix_G_shape = caculate_matmul_shape(self.in_channels, self.out_channels, split_dim) self.matrix_A_inv = Parameter(Tensor(np.zeros(matrix_A_shape).astype(np.float32)), requires_grad=False) self.matrix_G_inv = Parameter(Tensor(np.zeros(matrix_G_shape).astype(np.float32)), requires_grad=False) self.broadcast_to = P.BroadcastTo(matrix_A_shape) self.cov_step = Parameter(initializer(0, [1], mstype.int32), requires_grad=False) self.shape = P.Shape() self.reshape = P.Reshape() self.transpose = P.Transpose() self.mul = P.Mul() self.cube_matmul = P.MatMul(transpose_a=True) self.loss_scale = Tensor(1 / loss_scale, mstype.float16) self.batch_size = Tensor(batch_size, mstype.float16) self.getG = P.InsertGradientOf(self.save_gradient) self.damping = Parameter(Tensor(damping), requires_grad=False) self.dampingA = Tensor(np.identity(in_channels), mstype.float32) self.dampingG = Tensor(np.identity(out_channels), mstype.float32) self.cast = P.Cast() self.gather = P.Gather() self.freq = Tensor(frequency, mstype.int32) self.axis = 0 self.add = P.Add() self.sqrt = P.Sqrt() self.cholesky = P.CholeskyTrsm(split_dim=split_dim) self.vector_matmul = P.BatchMatMul(transpose_a=True)
def __init__(self, decay_policy='Linear', learning_rate=0.001, target_unclipped_quantile=0.9, fraction_stddev=0.01, seed=0): super(AdaClippingWithGaussianRandom, self).__init__() if decay_policy not in ['Linear', 'Geometric']: msg = "decay policy of adaptive clip must be in ['Linear', 'Geometric'], \ but got: {}".format(decay_policy) LOGGER.error(TAG, msg) raise ValueError(msg) self._decay_policy = decay_policy learning_rate = check_param_type('learning_rate', learning_rate, float) learning_rate = check_value_positive('learning_rate', learning_rate) self._learning_rate = Tensor(learning_rate, mstype.float32) fraction_stddev = check_param_type('fraction_stddev', fraction_stddev, float) self._fraction_stddev = Tensor(fraction_stddev, mstype.float32) target_unclipped_quantile = check_param_type( 'target_unclipped_quantile', target_unclipped_quantile, float) self._target_unclipped_quantile = Tensor(target_unclipped_quantile, mstype.float32) self._zero = Tensor(0, mstype.float32) self._add = P.Add() self._sub = P.Sub() self._mul = P.Mul() self._exp = P.Exp() seed = check_param_type('seed', seed, int) self._seed = check_value_non_negative('seed', seed)
def __init__(self): super().__init__() self.add = P.Add() self.sub = P.Sub() self.mul = P.Mul() self.div = P.RealDiv() self.net = Branch2Net()
def __init__(self, nptype): super(AddNet, self).__init__() self.add = P.Add() np.random.seed(0) self.x = Parameter(initializer( Tensor(np.random.randn(2, 0).astype(nptype)), [2, 0]), name='x') self.y = Parameter(initializer( Tensor(np.random.randn(2, 1).astype(nptype)), [2, 1]), name='y') self.x1 = Parameter(initializer( Tensor(np.arange(3).reshape(3).astype(nptype)), [3]), name='x1') self.y1 = Parameter(initializer( Tensor(np.array([2]).astype(nptype)), [1]), name='y1') self.x2 = Parameter(initializer( Tensor(np.arange(3 * 3 * 3 * 3).reshape(3, 3, 3, 3).astype(nptype)), [3, 3, 3, 3]), name='x2') self.y2 = Parameter(initializer( Tensor(np.arange(3 * 3 * 3 * 3).reshape(3, 3, 3, 3).astype(nptype)), [3, 3, 3, 3]), name='y2') self.x3 = Parameter(initializer( Tensor(np.arange(1 * 1 * 3 * 3).reshape(1, 1, 3, 3).astype(nptype)), [1, 1, 3, 3]), name='x3') self.y3 = Parameter(initializer( Tensor(np.arange(3 * 3 * 3 * 3).reshape(3, 3, 3, 3).astype(nptype)), [3, 3, 3, 3]), name='y3')
def __init__(self, in_channels, out_channels, stride=1, momentum=0.1): super(ResidualBlock, self).__init__() out_chls = out_channels // self.expansion self.conv1 = _conv(in_channels, out_chls, kernel_size=1, stride=1) self.bn1 = _bn(out_chls, momentum=momentum) self.conv2 = _conv(out_chls, out_chls, kernel_size=3, stride=stride, padding=1, pad_mode='pad') self.bn2 = _bn(out_chls, momentum=momentum) self.conv3 = _conv(out_chls, out_channels, kernel_size=1, stride=1) self.bn3 = _bn(out_channels, momentum=momentum) self.relu = P.ReLU() self.downsample = (in_channels != out_channels) self.stride = stride if self.downsample or self.stride != 1: self.conv_down_sample = _conv(in_channels, out_channels, kernel_size=1, stride=stride) self.bn_down_sample = _bn(out_channels, momentum=momentum) self.add = P.Add()
def __init__(self): """init function""" super(NewGeLU, self).__init__() self.mul_0 = P.Mul() self.mul_0_w = 0.5 self.pow_1 = P.Pow() self.pow_1_input_weight = 3.0 self.mul_2 = P.Mul() self.mul_2_w = 0.044714998453855515 self.add_3 = P.Add() self.mul_4 = P.Mul() self.mul_4_w = 0.7978845834732056 self.tanh_5 = nn.Tanh() self.add_6 = P.Add() self.add_6_bias = 1.0 self.mul_7 = P.Mul()
def __init__(self, inp, oup, stride, expand_ratio): super(InvertedResidual, self).__init__() assert stride in [1, 2] hidden_dim = int(round(inp * expand_ratio)) self.use_res_connect = stride == 1 and inp == oup layers = [] if expand_ratio != 1: layers.append(ConvBNReLU(inp, hidden_dim, kernel_size=1)) layers.extend([ ConvBNReLU(hidden_dim, hidden_dim, stride=stride, groups=hidden_dim), nn.Conv2dBnAct(hidden_dim, oup, kernel_size=1, stride=1, pad_mode='pad', padding=0, group=1, has_bn=True) ]) self.conv = nn.SequentialCell(layers) self.add = P.Add()
def __init__(self, batch_size, query_linear_bias, key_linear_bias, value_linear_bias): """init function""" super(MultiHeadAttn, self).__init__() self.batch_size = batch_size self.matmul = nn.MatMul() self.add = P.Add() self.reshape = P.Reshape() self.transpose = P.Transpose() self.div = P.Div() self.softmax = nn.Softmax(axis=3) self.query_linear_weight = Parameter(Tensor( np.random.uniform(0, 1, (4096, 4096)).astype(np.float32)), name=None) self.query_linear_bias = query_linear_bias self.key_linear_weight = Parameter(Tensor( np.random.uniform(0, 1, (4096, 4096)).astype(np.float32)), name=None) self.key_linear_bias = key_linear_bias self.value_linear_weight = Parameter(Tensor( np.random.uniform(0, 1, (4096, 4096)).astype(np.float32)), name=None) self.value_linear_bias = value_linear_bias self.reshape_shape = tuple([batch_size, 512, 64, 64]) self.w = Parameter(Tensor( np.random.uniform(0, 1, (64, 64, 4096)).astype(np.float32)), name=None) self.b = Parameter(Tensor( np.random.uniform(0, 1, (4096, )).astype(np.float32)), name=None)
def __init__(self, passthrough_w_0, passthrough_w_1): """init function""" super(LayerNorm, self).__init__() self.reducemean_0 = P.ReduceMean(keep_dims=True) self.sub_1 = P.Sub() self.pow_2 = P.Pow() self.pow_2_input_weight = 2.0 self.reducemean_3 = P.ReduceMean(keep_dims=True) self.add_4 = P.Add() self.add_4_bias = 9.999999960041972e-13 self.sqrt_5 = P.Sqrt() self.div_6 = P.Div() self.mul_7 = P.Mul() self.mul_7_w = passthrough_w_0 self.add_8 = P.Add() self.add_8_bias = passthrough_w_1
def __init__(self, num_classes=10): super(SqueezeNet_Residual, self).__init__() self.conv1 = nn.Conv2d(3, 96, kernel_size=7, stride=2, pad_mode='valid', has_bias=True) self.fire2 = Fire(96, 16, 64, 64) self.fire3 = Fire(128, 16, 64, 64) self.fire4 = Fire(128, 32, 128, 128) self.fire5 = Fire(256, 32, 128, 128) self.fire6 = Fire(256, 48, 192, 192) self.fire7 = Fire(384, 48, 192, 192) self.fire8 = Fire(384, 64, 256, 256) self.fire9 = Fire(512, 64, 256, 256) # Final convolution is initialized differently from the rest self.conv10 = nn.Conv2d(512, num_classes, kernel_size=1, has_bias=True) self.relu = nn.ReLU() self.max_pool2d = nn.MaxPool2d(kernel_size=3, stride=2) self.add = P.Add() self.dropout = nn.Dropout(keep_prob=0.5) self.mean = P.ReduceMean(keep_dims=True) self.flatten = nn.Flatten() self.custom_init_weight()
def __init__(self, num_in, num_mid, num_out, kernel_size, stride=1, act_type='relu', use_se=False, use_res_connect=True, last_relu=False): super(GhostBottleneck, self).__init__() self.ghost1 = GhostModule(num_in, num_mid, kernel_size=1, stride=1, padding=0, act_type=act_type) self.use_res_connect = use_res_connect self.last_relu = last_relu self.use_dw = stride > 1 self.dw = None if self.use_dw: self.dw = ConvBNReLU(num_mid, num_mid, kernel_size=kernel_size, stride=stride, act_type=act_type, groups=num_mid, use_act=False) self.use_se = use_se if use_se: self.se = SE(num_mid) self.ghost2 = GhostModule(num_mid, num_out, kernel_size=1, stride=1, padding=0, act_type=act_type, use_act=False) self.relu = nn.ReLU() if self.use_res_connect: self.down_sample = False if num_in != num_out or stride != 1: self.down_sample = True self.shortcut = None if self.down_sample: self.shortcut = nn.SequentialCell([ ConvBNReLU(num_in, num_in, kernel_size=kernel_size, stride=stride, groups=num_in, use_act=False), ConvBNReLU(num_in, num_out, kernel_size=1, stride=1, groups=1, use_act=False), ]) self.add = P.Add()
def __init__(self, batch_size=4): super(DiceLoss, self).__init__() self.threshold0 = Tensor(0.5, mstype.float32) self.zero_float32 = Tensor(0.0, mstype.float32) self.k = int(640 * 640) self.negative_one_int32 = Tensor(-1, mstype.int32) self.batch_size = batch_size self.concat = P.Concat() self.less_equal = P.LessEqual() self.greater = P.Greater() self.reduce_sum = P.ReduceSum() self.reduce_sum_keep_dims = P.ReduceSum(keep_dims=True) self.reduce_mean = P.ReduceMean() self.reduce_min = P.ReduceMin() self.cast = P.Cast() self.minimum = P.Minimum() self.expand_dims = P.ExpandDims() self.select = P.Select() self.fill = P.Fill() self.topk = P.TopK(sorted=True) self.shape = P.Shape() self.sigmoid = P.Sigmoid() self.reshape = P.Reshape() self.slice = P.Slice() self.logical_and = P.LogicalAnd() self.logical_or = P.LogicalOr() self.equal = P.Equal() self.zeros_like = P.ZerosLike() self.add = P.Add() self.gather = P.Gather()
def __init__(self, summary_type, tag, data): super(SummaryNet, self).__init__() self.tag = tag self.data = data self.summary_fn = getattr(P, summary_type)() self.one = Tensor(np.array([1]).astype(np.float32)) self.add = P.Add()
def __init__(self): super(Assign_WAR, self).__init__() self.assign = P.Assign() self.sub = P.Sub() self.add = P.Add() self.para = Parameter(Tensor(1, dtype=ms.int32), name='para') self.weight = Parameter(Tensor(5, dtype=ms.int32), name='weight')
def __init__(self): super(LogSigmoid, self).__init__() self.mul = P.Mul() self.exp = P.Exp() self.add = P.Add() self.rec = P.Reciprocal() self.log = P.Log()
def __init__(self, in_channels, out_channels, stride=1, down_sample=False): super(ResidualBlock, self).__init__() out_chls = out_channels // self.expansion self.conv1 = conv1x1(in_channels, out_chls, stride=1, padding=0) self.bn1 = nn.BatchNorm2d(out_chls) self.conv2 = conv3x3(out_chls, out_chls, stride=stride, padding=1) self.bn2 = nn.BatchNorm2d(out_chls) self.conv3 = conv1x1(out_chls, out_channels, stride=1, padding=0) self.bn3 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU() self.downsample = down_sample if self.downsample: self.conv_down_sample = conv1x1(in_channels, out_channels, stride=stride, padding=0) self.bn_down_sample = nn.BatchNorm2d(out_channels) self.add = P.Add()
def __init__(self, in_channel, out_channel, stride=1): super(ResidualBlock, self).__init__() channel = out_channel // self.expansion self.conv1 = _conv1x1(in_channel, channel, stride=1) self.bn1 = _bn(channel) self.conv2 = _conv3x3(channel, channel, stride=stride) self.bn2 = _bn(channel) self.conv3 = _conv1x1(channel, out_channel, stride=1) 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), _bn(out_channel)]) self.add = P.Add()
def __init__(self, mul_7_w_shape, add_8_bias_shape): """init function""" super(LayerNorm, self).__init__() self.reducemean_0 = P.ReduceMean(keep_dims=True) self.sub_1 = P.Sub() self.pow_2 = P.Pow() self.pow_2_input_weight = 2.0 self.reducemean_3 = P.ReduceMean(keep_dims=True) self.add_4 = P.Add() self.add_4_bias = 9.999999960041972e-13 self.sqrt_5 = P.Sqrt() self.div_6 = P.Div() self.mul_7 = P.Mul() self.mul_7_w = Parameter(Tensor(np.random.uniform(0, 1, mul_7_w_shape).astype(np.float32)), name=None) self.add_8 = P.Add() self.add_8_bias = Parameter(Tensor(np.random.uniform(0, 1, add_8_bias_shape).astype(np.float32)), name=None)
def __init__(self, in_channels, out_channels, stride=1, momentum=0.9): super(ResidualBlock, self).__init__() out_chls = out_channels // self.expansion self.conv1 = _conv1x1(in_channels, out_chls, stride=1) self.bn1 = _fused_bn(out_chls, momentum=momentum) self.conv2 = _conv3x3(out_chls, out_chls, stride=stride) self.bn2 = _fused_bn(out_chls, momentum=momentum) self.conv3 = _conv1x1(out_chls, out_channels, stride=1) self.bn3 = _fused_bn(out_channels, momentum=momentum) self.relu = P.ReLU() self.downsample = (in_channels != out_channels) self.stride = stride if self.downsample: self.conv_down_sample = _conv1x1(in_channels, out_channels, stride=stride) self.bn_down_sample = _fused_bn(out_channels, momentum=momentum) elif self.stride != 1: self.maxpool_down = nn.MaxPool2d(kernel_size=1, stride=2, pad_mode='same') self.add = P.Add()
def construct(self, a, b, x): if a < b: a = P.Add()(a, b) else: a = P.Sub()(a, b) if a == x: a = P.Mul()(a, b) else: a = P.RealDiv()(a, b) if b == x: b = P.Add()(a, b) else: b = P.Add()(a, x) a = a * b out = a + b + x return out