def __init__(self,
batch_size,
conv_out_dim,
encoder_hidden_size,
decoder_hidden_size,
decoder_output_size,
max_length,
dropout_p=0.1):
super(AttentionOCR, self).__init__()
self.encoder = Encoder(batch_size=batch_size,
conv_out_dim=conv_out_dim,
hidden_size=encoder_hidden_size)
self.decoder = Decoder(hidden_size=decoder_hidden_size,
output_size=decoder_output_size,
max_length=max_length,
dropout_p=dropout_p)
self.init_decoder_hidden = Tensor(
np.zeros((1, batch_size, decoder_hidden_size), dtype=np.float16),
mstype.float16)
self.shape = P.Shape()
self.split = P.Split(axis=1, output_num=max_length)
self.concat = P.Concat()
self.expand_dims = P.ExpandDims()
self.argmax = P.Argmax()
self.select = P.Select()
def __init__(self):
super(BoundingBoxEncode, self).__init__()
self.split = P.Split(axis=1, output_num=4)
self.ones = 1.0
self.half = 0.5
self.log = P.Log()
self.concat = P.Concat(axis=1)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride,
pad_mode="pad",
pad=0,
groups=1,
has_bias=False):
super(GroupConv, self).__init__()
assert in_channels % groups == 0 and out_channels % groups == 0
self.groups = groups
self.convs = nn.CellList()
self.op_split = P.Split(axis=1, output_num=self.groups)
self.op_concat = P.Concat(axis=1)
self.cast = P.Cast()
for _ in range(groups):
self.convs.append(
nn.Conv2d(in_channels // groups,
out_channels // groups,
kernel_size=kernel_size,
stride=stride,
has_bias=has_bias,
padding=pad,
pad_mode=pad_mode,
group=1,
weight_init='xavier_uniform'))
def __init__(self,
config,
batch_size,
num_classes,
use_sigmoid_cls,
target_means=(.0, .0, .0, .0),
target_stds=(1.0, 1.0, 1.0, 1.0)
):
super(Proposal, self).__init__()
cfg = config
self.batch_size = batch_size
self.num_classes = num_classes
self.target_means = target_means
self.target_stds = target_stds
self.use_sigmoid_cls = config.use_sigmoid_cls
if self.use_sigmoid_cls:
self.cls_out_channels = 1
self.activation = P.Sigmoid()
self.reshape_shape = (-1, 1)
else:
self.cls_out_channels = num_classes
self.activation = P.Softmax(axis=1)
self.reshape_shape = (-1, 2)
if self.cls_out_channels <= 0:
raise ValueError('num_classes={} is too small'.format(num_classes))
self.num_pre = cfg.rpn_proposal_nms_pre
self.min_box_size = cfg.rpn_proposal_min_bbox_size
self.nms_thr = cfg.rpn_proposal_nms_thr
self.nms_post = cfg.rpn_proposal_nms_post
self.nms_across_levels = cfg.rpn_proposal_nms_across_levels
self.max_num = cfg.rpn_proposal_max_num
# Op Define
self.squeeze = P.Squeeze()
self.reshape = P.Reshape()
self.cast = P.Cast()
self.feature_shapes = cfg.feature_shapes
self.transpose_shape = (1, 2, 0)
self.decode = BoundingBoxDecode()
self.nms = P.NMSWithMask(self.nms_thr)
self.concat_axis0 = P.Concat(axis=0)
self.concat_axis1 = P.Concat(axis=1)
self.split = P.Split(axis=1, output_num=5)
self.min = P.Minimum()
self.gatherND = P.GatherNd()
self.slice = P.Slice()
self.select = P.Select()
self.greater = P.Greater()
self.transpose = P.Transpose()
self.tile = P.Tile()
self.set_train_local(config, training=True)
self.multi_10 = Tensor(10.0, mstype.float16)
def __init__(self, config, scale=1.0, layer_idx=None):
super(Attention, self).__init__()
self.get_attention_mask = AttentionMask(config)
self.projection = Mapping(config.embedding_size, config.embedding_size,
config.compute_dtype, scale)
self.split = P.Split(axis=-1, output_num=3)
self.transpose = P.Transpose()
self.reshape = P.Reshape()
self.n_head = config.num_heads
self.size_per_head = config.embedding_size // self.n_head
self.concat_k = P.Concat(axis=3)
self.concat_v = P.Concat(axis=2)
self.multiply_data = Tensor([
-10000.0,
], dtype=mstype.float32)
self.batch_matmul = P.BatchMatMul()
self.scale = scale
if self.scale:
self.scale_factor = Tensor(math.sqrt(self.size_per_head))
if layer_idx is not None:
self.coeff = math.sqrt(layer_idx * math.sqrt(self.size_per_head))
self.coeff = Tensor(self.coeff)
self.use_past = config.use_past
self.dropout = nn.Dropout(1 - config.dropout_rate)
self.prob_dropout = nn.Dropout(1 - config.dropout_rate)
self.dense1 = nn.Dense(config.embedding_size,
config.embedding_size).to_float(
config.compute_dtype)
self.dense2 = nn.Dense(config.embedding_size,
config.embedding_size).to_float(
config.compute_dtype)
self.dense3 = nn.Dense(config.embedding_size,
config.embedding_size).to_float(
config.compute_dtype)
def __init__(self, network, optimizer, sens=1.0, micro_batches=None, norm_clip=1.0, mech=None):
super(_TrainOneStepCell, self).__init__(auto_prefix=False)
self.network = network
self.network.set_grad()
self.network.add_flags(defer_inline=True)
self.weights = optimizer.parameters
self.optimizer = optimizer
self.grad = C.GradOperation('grad', get_by_list=True, sens_param=True)
self.sens = sens
self.reducer_flag = False
self.grad_reducer = None
parallel_mode = _get_parallel_mode()
if parallel_mode in (ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL):
self.reducer_flag = True
if self.reducer_flag:
mean = _get_mirror_mean()
degree = _get_device_num()
self.grad_reducer = DistributedGradReducer(optimizer.parameters, mean, degree)
# dp params
self._micro_batches = micro_batches
norm_clip = check_param_type('norm_clip', norm_clip, float)
self._l2_norm = check_value_positive('norm_clip', norm_clip)
self._split = P.Split(0, self._micro_batches)
self._clip_by_global_norm = _ClipGradients()
self._mech = mech
self._tuple_add = _TupleAdd()
self._hyper_map = C.HyperMap()
self._micro_float = Tensor(micro_batches, mstype.float32)
def test_out_int64():
op = P.Split(5, 2)
op_wrapper = OpNetWrapper(op)
input_x = Tensor(
np.arange(192).astype(np.int64).reshape((2, 2, 2, 2, 2, 6)))
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[0, 0, 0, 0, 0, :], [0, 1, 2])
assert np.allclose(outputs[1].asnumpy()[0, 0, 0, 0, 0, :], [3, 4, 5])
op = P.Split(5, 3)
op_wrapper = OpNetWrapper(op)
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[1, 0, 0, 0, 0, :], [96, 97])
assert np.allclose(outputs[1].asnumpy()[1, 0, 0, 0, 0, :], [98, 99])
assert np.allclose(outputs[2].asnumpy()[1, 0, 0, 0, 0, :], [100, 101])
def test_out_float32():
op = P.Split(5, 2)
op_wrapper = OpNetWrapper(op)
input_x = Tensor(
np.arange(192).astype(np.float32).reshape((2, 2, 2, 2, 2, 6)))
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[0, 0, 0, 0, 0, :], [0., 1., 2.])
assert np.allclose(outputs[1].asnumpy()[0, 0, 0, 0, 0, :], [3., 4., 5.])
op = P.Split(5, 3)
op_wrapper = OpNetWrapper(op)
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[0, 0, 0, 0, 0, :], [0., 1.])
assert np.allclose(outputs[1].asnumpy()[0, 0, 0, 0, 0, :], [2., 3.])
assert np.allclose(outputs[2].asnumpy()[0, 0, 0, 0, 0, :], [4., 5.])
def __init__(self, dataset_argv, architect_argv, activation,
neigh_drop_rate, num_user, num_item, input_dim):
super(BGCF, self).__init__()
self.user_embed = Parameter(
initializer("XavierUniform", [num_user, input_dim],
dtype=mstype.float32))
self.item_embed = Parameter(
initializer("XavierUniform", [num_item, input_dim],
dtype=mstype.float32))
self.cast = P.Cast()
self.tanh = P.Tanh()
self.shape = P.Shape()
self.split = P.Split(0, 2)
self.gather = P.Gather()
self.reshape = P.Reshape()
self.concat_0 = P.Concat(0)
self.concat_1 = P.Concat(1)
(self.input_dim, self.num_user, self.num_item) = dataset_argv
self.layer_dim = architect_argv
self.gnew_agg_mean = MeanConv(self.input_dim,
self.layer_dim,
activation=activation,
dropout=neigh_drop_rate[1])
self.gnew_agg_mean.to_float(mstype.float16)
self.gnew_agg_user = AttenConv(self.input_dim,
self.layer_dim,
dropout=neigh_drop_rate[2])
self.gnew_agg_user.to_float(mstype.float16)
self.gnew_agg_item = AttenConv(self.input_dim,
self.layer_dim,
dropout=neigh_drop_rate[2])
self.gnew_agg_item.to_float(mstype.float16)
self.user_feature_dim = self.input_dim
self.item_feature_dim = self.input_dim
self.final_weight = Parameter(
initializer("XavierUniform",
[self.input_dim * 3, self.input_dim * 3],
dtype=mstype.float32))
self.raw_agg_funcs_user = MeanConv(self.input_dim,
self.layer_dim,
activation=activation,
dropout=neigh_drop_rate[0])
self.raw_agg_funcs_user.to_float(mstype.float16)
self.raw_agg_funcs_item = MeanConv(self.input_dim,
self.layer_dim,
activation=activation,
dropout=neigh_drop_rate[0])
self.raw_agg_funcs_item.to_float(mstype.float16)
def __init__(self):
super(EAST, self).__init__()
#param
self.TEXT_SCALE = 512
self.pi = math.pi / 1.
self.pi = mindspore.Tensor([self.pi], mindspore.float32)
#network
self.model = vgg.vgg16()
#for i = 0
self.split = P.Split(1, 2)
self.unpool0 = unpool((32, 32))
self._concat = P.Concat(axis=1)
#for i = 1
self.concat1 = P.Concat(axis=1)
self.conv1_1 = ops.conv_bn_relu(1024, 128, stride=1, kernel_size=1, padding='valid')
self.conv1_2 = ops.conv_bn_relu(128, 128, stride=1, kernel_size=3, padding='pad', padding_number=1)
self.unpool1 = unpool((64, 64))
#for i = 2
self.concat2 = P.Concat(axis=1)
self.conv2_1 = ops.conv_bn_relu(384, 64, stride=1, kernel_size=1, padding='valid')
self.conv2_2 = ops.conv_bn_relu(64, 64, stride=1, kernel_size=3, padding='pad', padding_number=1)
self.unpool2 = unpool((128, 128))
#for i = 3
self.concat3 = P.Concat(axis=1)
self.conv3_1 = ops.conv_bn_relu(192, 32, stride=1, kernel_size=1, padding='valid')
self.conv3_2 = ops.conv_bn_relu(32, 32, stride=1, kernel_size=3, padding='pad', padding_number=1)
self.conv3_3 = ops.conv_bn_relu(32, 32, stride=1, kernel_size=3, padding='pad', padding_number=1)
#output
## F_score
self.conv_for_fscore = ops._conv(32, 1, stride=1, kernel_size=1, padding='valid')
self.sigmoid_for_fscore = nn.Sigmoid()
## geo_map
self.conv_for_geo_map = ops._conv(32, 4, stride=1, kernel_size=1, padding='valid')
self.sigmoid_for_geo_map = nn.Sigmoid()
## angle_map
self.conv_for_angle_map = ops._conv(32, 1, stride=1, kernel_size=1, padding='valid')
self.sigmoid_for_angle_map = nn.Sigmoid()
## F_geometry
self.concat_for_F_geometry = P.Concat(axis=1)
## other
self.mul = P.Mul()
self.add = P.TensorAdd()
def __init__(self,
batch_size=512,
d_model=768,
seq_length=1024,
num_attention_heads=12,
dim_per_head=64,
has_attention_mask=True,
do_return_2d_tensor=True,
attention_dropout=0.0,
compute_type=mstype.float32):
super(MaskedSelfAttention, self).__init__()
self.batch_size = batch_size
self.d_model = d_model
self.seq_length = seq_length
self.num_heads = num_attention_heads
self.dim_per_head = dim_per_head
self.has_attention_mask = has_attention_mask
assert has_attention_mask
self.scale = Tensor([1.0 / math.sqrt(float(self.dim_per_head))],
dtype=compute_type) # attention scale
self.mask_data = Tensor([
-10000.0,
], dtype=compute_type)
self.split_head_shape = (self.batch_size, self.seq_length,
self.num_heads, self.dim_per_head)
self.c_attn = Conv1D(d_model, d_model * 3)
self.c_proj = Conv1D(d_model, d_model)
self.split_for_qkv = P.Split(1, 3) # P.Split(axis, output_num)
# self.shape = P.Shape()
self.reshape = P.Reshape()
self.transpose = P.Transpose()
self.trans_shape = (0, 2, 1, 3)
self.matmul_trans_b = P.BatchMatMul(transpose_b=True)
self.matmul = P.BatchMatMul()
self.multiply = P.Mul()
if self.has_attention_mask:
self.expand_dims = P.ExpandDims()
self.sub = P.Sub()
self.add = P.TensorAdd()
self.cast = P.Cast()
self.get_dtype = P.DType()
if do_return_2d_tensor:
self.shape_return = (batch_size * seq_length, d_model)
else:
self.shape_return = (batch_size, seq_length, d_model)
self.softmax = nn.Softmax()
self.softmax_cast = P.Cast()
self.dropout = nn.Dropout(1 - attention_dropout)
self.use_attention_dropout = attention_dropout > 0
def __init__(self, network, max_length):
super(AttentionOCRWithLossCell, self).__init__()
self.network = network
self.loss = NLLLoss()
self.shape = P.Shape()
self.add = P.AddN()
self.mean = P.ReduceMean()
self.split = P.Split(axis=0, output_num=max_length)
self.squeeze = P.Squeeze()
self.cast = P.Cast()
def construct(self, input_data, target_features):
"""
Calculate the inversion attack loss, which consists of three parts. Loss_1 is for evaluating the difference
between the target deep representations and current representations; Loss_2 is for evaluating the continuity
between adjacent pixels; Loss_3 is for regularization.
Args:
input_data (Tensor): The reconstructed image during inversion attack.
target_features (Tensor): Deep representations of the original image.
Returns:
Tensor, inversion attack loss of the current iteration.
"""
output = self._network(input_data)
loss_1 = self._mse_loss(output, target_features) / self._mse_loss(
target_features, self._zeros(target_features))
data_shape = self._get_shape(input_data)
if self._device_target == 'CPU':
split_op_1 = P.Split(2, data_shape[2])
split_op_2 = P.Split(3, data_shape[3])
data_split_1 = split_op_1(input_data)
data_split_2 = split_op_2(input_data)
loss_2 = 0
for i in range(1, data_shape[2]):
loss_2 += self._mse_loss(data_split_1[i], data_split_1[i - 1])
for j in range(1, data_shape[3]):
loss_2 += self._mse_loss(data_split_2[j], data_split_2[j - 1])
else:
data_copy_1 = self._zeros(input_data)
data_copy_2 = self._zeros(input_data)
data_copy_1[:, :, :(data_shape[2] - 1), :] = input_data[:, :,
1:, :]
data_copy_2[:, :, :, :(data_shape[2] - 1)] = input_data[:, :, :,
1:]
loss_2 = self._mse_loss(input_data, data_copy_1) + self._mse_loss(
input_data, data_copy_2)
loss_3 = self._mse_loss(input_data, self._zeros(input_data))
loss = loss_1 * self._weights[0] + loss_2 * self._weights[
1] + loss_3 * self._weights[2]
return loss
def __init__(self,
mul_weight,
axis=0,
out_nums=1,
strategy1=None,
strategy2=None):
super(Net2, self).__init__()
self.split = P.Split(axis, out_nums).shard(strategy1)
self.mul = P.Mul().shard(strategy2)
self.weight = Parameter(mul_weight, "w1")
def test_out1_axis0():
op = P.Split(0, 1)
op_wrapper = OpNetWrapper(op)
input_x = Tensor(np.arange(24).astype(np.int32).reshape((2, 2, 6)))
outputs = op_wrapper(input_x)
print(outputs)
assert outputs[0].shape == (2, 2, 6)
assert np.allclose(outputs[0].asnumpy()[0, 0, :], [0, 1, 2, 3, 4, 5])
def test_out_uint32():
op = P.Split(-1, 2)
op_wrapper = OpNetWrapper(op)
input_x = Tensor(
np.arange(320).astype(np.uint32).reshape((2, 2, 2, 2, 2, 10)))
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[0, 0, 0, 0, 0, :], [0, 1, 2, 3, 4])
assert np.allclose(outputs[1].asnumpy()[0, 0, 0, 0, 0, :], [5, 6, 7, 8, 9])
op = P.Split(-1, 5)
op_wrapper = OpNetWrapper(op)
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[1, 1, 1, 1, 1, :], [310, 311])
assert np.allclose(outputs[1].asnumpy()[1, 1, 1, 1, 1, :], [312, 313])
assert np.allclose(outputs[2].asnumpy()[1, 1, 1, 1, 1, :], [314, 315])
assert np.allclose(outputs[3].asnumpy()[1, 1, 1, 1, 1, :], [316, 317])
assert np.allclose(outputs[4].asnumpy()[1, 1, 1, 1, 1, :], [318, 319])
op = P.Split(-2, 2)
op_wrapper = OpNetWrapper(op)
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[0, 0, 0, 0, :, 0], [0])
assert np.allclose(outputs[1].asnumpy()[0, 0, 0, 0, :, 1], [11])
assert np.allclose(outputs[0].asnumpy()[1, 0, 0, 0, :, 2], [162])
assert np.allclose(outputs[1].asnumpy()[1, 0, 0, 0, :, 3], [173])
assert np.allclose(outputs[0].asnumpy()[1, 1, 0, 0, :, 4], [244])
assert np.allclose(outputs[1].asnumpy()[1, 1, 0, 0, :, 5], [255])
assert np.allclose(outputs[0].asnumpy()[1, 1, 1, 0, :, 6], [286])
assert np.allclose(outputs[1].asnumpy()[1, 1, 1, 0, :, 7], [297])
assert np.allclose(outputs[0].asnumpy()[1, 1, 1, 1, :, 8], [308])
assert np.allclose(outputs[1].asnumpy()[1, 1, 1, 1, :, 9], [319])
op = P.Split(-1, 1)
op_wrapper = OpNetWrapper(op)
input_x = Tensor(np.arange(1).astype(np.uint32))
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy(), [0])
def __init__(self, batch_size, conv_out_dim, hidden_size):
super(Encoder, self).__init__()
self.cnn = CNN(int(conv_out_dim / 4))
self.lstm1 = BidirectionalLSTM(batch_size, conv_out_dim, hidden_size,
hidden_size).to_float(mstype.float16)
self.lstm2 = BidirectionalLSTM(batch_size, hidden_size, hidden_size,
hidden_size).to_float(mstype.float16)
self.transpose = P.Transpose()
self.cast = P.Cast()
self.split = P.Split(axis=3, output_num=4)
self.concat = P.Concat(axis=1)
def test_mode_init(self, config):
self.test_batch_size = config.test_batch_size
self.split = P.Split(axis=0, output_num=self.test_batch_size)
self.split_shape = P.Split(axis=0, output_num=4)
self.split_scores = P.Split(axis=1, output_num=self.num_classes)
self.split_cls = P.Split(axis=0, output_num=self.num_classes - 1)
self.tile = P.Tile()
self.gather = P.GatherNd()
self.rpn_max_num = config.rpn_max_num
self.zeros_for_nms = Tensor(
np.zeros((self.rpn_max_num, 3)).astype(self.dtype))
self.ones_mask = np.ones((self.rpn_max_num, 1)).astype(np.bool)
self.zeros_mask = np.zeros((self.rpn_max_num, 1)).astype(np.bool)
self.bbox_mask = Tensor(
np.concatenate((self.ones_mask, self.zeros_mask, self.ones_mask,
self.zeros_mask),
axis=1))
self.nms_pad_mask = Tensor(
np.concatenate((self.ones_mask, self.ones_mask, self.ones_mask,
self.ones_mask, self.zeros_mask),
axis=1))
self.test_score_thresh = Tensor(
np.ones((self.rpn_max_num, 1)).astype(self.dtype) *
config.test_score_thr)
self.test_score_zeros = Tensor(
np.ones((self.rpn_max_num, 1)).astype(self.dtype) * 0)
self.test_box_zeros = Tensor(
np.ones((self.rpn_max_num, 4)).astype(self.dtype) * -1)
self.test_iou_thr = Tensor(
np.ones((self.rpn_max_num, 1)).astype(self.dtype) *
config.test_iou_thr)
self.test_max_per_img = config.test_max_per_img
self.nms_test = P.NMSWithMask(config.test_iou_thr)
self.softmax = P.Softmax(axis=1)
self.logicand = P.LogicalAnd()
self.oneslike = P.OnesLike()
self.test_topk = P.TopK(sorted=True)
self.test_num_proposal = self.test_batch_size * self.rpn_max_num
def __init__(self, weight_angle=10):
super(LossFunc, self).__init__()
self.split = P.Split(1, 5)
self.min = P.Minimum()
self.log = P.Log()
self.cos = P.Cos()
self.mean = P.ReduceMean()
#self.flatten = P.Flatten()
self.sum = P.ReduceSum()
self.weight_angle = weight_angle
self.max = P.Maximum()
self.print = P.Print()
def test_out2_axis1neg():
op = P.Split(-1, 2)
op_wrapper = OpNetWrapper(op)
input_x = Tensor(np.arange(24).astype(np.float32).reshape((2, 2, 6)))
outputs = op_wrapper(input_x)
print(outputs)
assert np.allclose(outputs[0].asnumpy()[0, :, :],
[[0., 1., 2.], [6., 7., 8.]])
assert np.allclose(outputs[1].asnumpy()[0, :, :],
[[3., 4., 5.], [9., 10., 11.]])
def __init__(self, residual_channels=None, gate_channels=None, kernel_size=None, skip_out_channels=None, bias=True,
dropout=1 - 0.95, dilation=1, cin_channels=-1, gin_channels=-1, padding=None, causal=True):
super(ResidualConv1dGLU, self).__init__()
self.dropout = dropout
self.dropout_op = nn.Dropout(keep_prob=1. - self.dropout)
self.eval_split_op = P.Split(axis=-1, output_num=2)
self.train_split_op = P.Split(axis=1, output_num=2)
self.tanh = P.Tanh()
self.sigmoid = P.Sigmoid()
self.mul = P.Mul()
self.add = P.TensorAdd()
if skip_out_channels is None:
skip_out_channels = residual_channels
if padding is None:
if causal:
padding = (kernel_size - 1) * dilation
else:
padding = (kernel_size - 1) // 2 * dilation
self.causal = causal
self.conv = Conv1d(residual_channels, gate_channels, kernel_size, pad_mode='pad',
padding=padding, dilation=dilation, has_bias=bias)
# local conditioning
if cin_channels > 0:
self.conv1x1c = Conv1d1x1(cin_channels, gate_channels, has_bias=False)
else:
self.conv1x1c = None
# global conditioning
if gin_channels > 0:
self.conv1x1g = Conv1d(gin_channels, gate_channels, has_bias=False, kernel_size=1, dilation=1)
else:
self.conv1x1g = None
gate_out_channels = gate_channels // 2
self.conv1x1_out = Conv1d1x1(gate_out_channels, residual_channels, has_bias=bias)
self.conv1x1_skip = Conv1d1x1(gate_out_channels, skip_out_channels, has_bias=bias)
self.factor = math.sqrt(0.5)
def __init__(self,
mul_weight,
axis=0,
out_nums=1,
strategy1=None,
strategy2=None,
strategy3=None):
super(Net, self).__init__()
self.split = P.Split(axis, out_nums).shard(strategy1)
self.mul = P.Mul().shard(strategy2)
self.matmul = P.MatMul(transpose_b=True).shard(strategy2)
self.matmul2 = P.MatMul().shard(strategy3)
self.weight = Parameter(mul_weight, "w1")
def test_out_float16():
op = P.Split(-1, 2)
op_wrapper = OpNetWrapper(op)
input_x = Tensor(
np.arange(320).astype(np.float16).reshape((2, 2, 2, 2, 2, 10)))
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[0, 0, 0, 0, 0, :],
[0., 1., 2., 3., 4.])
assert np.allclose(outputs[1].asnumpy()[0, 0, 0, 0, 0, :],
[5., 6., 7., 8., 9.])
op = P.Split(-1, 5)
op_wrapper = OpNetWrapper(op)
outputs = op_wrapper(input_x)
assert np.allclose(outputs[0].asnumpy()[0, 0, 0, 0, 0, :], [0., 1.])
assert np.allclose(outputs[1].asnumpy()[0, 0, 0, 0, 0, :], [2., 3.])
assert np.allclose(outputs[2].asnumpy()[0, 0, 0, 0, 0, :], [4., 5.])
assert np.allclose(outputs[3].asnumpy()[0, 0, 0, 0, 0, :], [6., 7.])
assert np.allclose(outputs[4].asnumpy()[0, 0, 0, 0, 0, :], [8., 9.])
def __init__(self, network):
super(GRUWithLossCell, self).__init__()
self.network = network
self.loss = NLLLoss()
self.logits_shape = (-1, config.src_vocab_size)
self.reshape = P.Reshape()
self.cast = P.Cast()
self.mean = P.ReduceMean()
self.text_len = config.max_length
self.split = P.Split(axis=0, output_num=config.max_length-1)
self.squeeze = P.Squeeze()
self.add = P.AddN()
self.transpose = P.Transpose()
self.shape = P.Shape()
def __init__(self, network, optimizer, scale_update_cell=None, micro_batches=None, norm_clip=1.0, mech=None):
super(_TrainOneStepWithLossScaleCell, self).__init__(auto_prefix=False)
self.network = network
self.network.set_grad()
self.network.add_flags(defer_inline=True)
self.weights = ParameterTuple(network.trainable_params())
self.optimizer = optimizer
self.grad = C.GradOperation('grad', get_by_list=True, sens_param=True)
self.hyper_map = C.HyperMap()
if context.get_context("device_target") == "GPU":
self.gpu_target = True
self.float_status = P.FloatStatus()
self.addn = P.AddN()
self.reshape = P.Reshape()
else:
self.gpu_target = False
self.alloc_status = NPUAllocFloatStatus()
self.get_status = NPUGetFloatStatus()
self.clear_status = NPUClearFloatStatus()
self.reduce_sum = ReduceSum(keep_dims=False)
self.base = Tensor(1, mstype.float32)
self.less_equal = LessEqual()
self.depend_parameter_use = ControlDepend(depend_mode=1)
self.allreduce = P.AllReduce()
self.parallel_mode = _get_parallel_mode()
self.grad_reducer = F.identity
self.reducer_flag = self.parallel_mode in [ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL]
if self.reducer_flag:
mean = _get_mirror_mean()
degree = _get_device_num()
self.grad_reducer = DistributedGradReducer(optimizer.parameters, mean, degree)
self.is_distributed = self.parallel_mode != ParallelMode.STAND_ALONE
self.loss_scale = None
self.loss_scaling_manager = scale_update_cell
if scale_update_cell:
self.loss_scale = Parameter(Tensor(scale_update_cell.get_loss_scale(), dtype=mstype.float32),
name="loss_scale")
self.add_flags(has_effect=True)
# dp params
self._micro_batches = micro_batches
norm_clip = check_param_type('norm_clip', norm_clip, float)
self._l2_norm = check_value_positive('norm_clip', norm_clip)
self._split = P.Split(0, self._micro_batches)
self._clip_by_global_norm = _ClipGradients()
self._mech = mech
self._tuple_add = _TupleAdd()
self._hyper_map = C.HyperMap()
self._micro_float = Tensor(micro_batches, mstype.float32)
def __init__(self,
block,
layer_nums,
in_channels,
out_channels,
strides,
low_dims,
training_mode=True,
use_MLP=False):
super(ResNet, self).__init__()
if not len(layer_nums) == len(in_channels) == len(out_channels) == 4:
raise ValueError("the length of layer_num, in_channels, out_channels list must be 4!")
self.use_MLP = use_MLP
self.training_mode = training_mode
self.concat = P.Concat()
self.split = P.Split(0, 3)
self.l2norm = P.L2Normalize(axis=1)
self.conv1 = _conv3x3(3, 64, stride=1)
self.bn1 = _bn(64, training_mode)
self.relu = nn.ReLU()
self.layer1 = self._make_layer(block,
layer_nums[0],
in_channel=in_channels[0],
out_channel=out_channels[0],
stride=strides[0])
self.layer2 = self._make_layer(block,
layer_nums[1],
in_channel=in_channels[1],
out_channel=out_channels[1],
stride=strides[1])
self.layer3 = self._make_layer(block,
layer_nums[2],
in_channel=in_channels[2],
out_channel=out_channels[2],
stride=strides[2])
self.layer4 = self._make_layer(block,
layer_nums[3],
in_channel=in_channels[3],
out_channel=out_channels[3],
stride=strides[3])
self.mean = P.ReduceMean(keep_dims=True)
self.flatten = nn.Flatten()
self.end_point = _fc(block.expansion * 512, low_dims)
self.mlp_layer1 = _fc(block.expansion * 512, block.expansion * 512)
self.mlp_layer2 = _fc(block.expansion * 512, low_dims)
def __init__(self, in_chs, num_1x1_a, num_3x3_b, num_1x1_c, inc, G, key_stride):
super(BottleBlock, self).__init__()
self.G = G
self.bn1 = nn.BatchNorm2d(in_chs, eps=1e-3, momentum=0.9)
self.conv1 = nn.Conv2d(in_chs, num_1x1_a, 1, stride=1)
self.bn2 = nn.BatchNorm2d(num_1x1_a, eps=1e-3, momentum=0.9)
self.conv2 = nn.CellList()
for _ in range(G):
self.conv2.append(nn.Conv2d(num_1x1_a // G, num_3x3_b // G, 3, key_stride, pad_mode='pad', padding=1))
self.bn3 = nn.BatchNorm2d(num_3x3_b, eps=1e-3, momentum=0.9)
self.conv3_r = nn.Conv2d(num_3x3_b, num_1x1_c, 1, stride=1)
self.conv3_d = nn.Conv2d(num_3x3_b, inc, 1, stride=1)
self.relu = nn.ReLU()
self.concat = F.Concat(axis=1)
self.split = F.Split(axis=1, output_num=G)
def __init__(self):
super(Processing, self).__init__()
self.slice = P.Slice()
self.reshape = P.Reshape()
self.shape = P.Shape()
self.batchmat = nn.MatMul()
self.split = P.Split(1, 3)
self.concat = P.Concat(axis=1)
slice_64 = Tensor(np.hstack((np.identity(64), np.zeros([64, 128]))))
slice_128 = Tensor(np.hstack((np.zeros([128, 64]), np.identity(128))))
self.slice_0 = [slice_64, slice_128]
slice_46 = Tensor(np.hstack((np.identity(46), np.zeros([46, 92]))))
slice_92 = Tensor(np.hstack((np.zeros([92, 46]), np.identity(92))))
self.slice_1 = [slice_46, slice_92]
slice_2 = np.vstack((np.identity(1), np.zeros([3, 1])))
self.slice_2 = Tensor(slice_2)
def construct(self, output, target, target_weight):
batch_size = F.shape(output)[0]
num_joints = F.shape(output)[1]
split = P.Split(1, num_joints)
heatmaps_pred = self.reshape(output, (batch_size, num_joints, -1))
heatmaps_pred = split(heatmaps_pred)
heatmaps_gt = self.reshape(target, (batch_size, num_joints, -1))
heatmaps_gt = split(heatmaps_gt)
loss = 0
for idx in range(num_joints):
heatmap_pred = self.squeeze(heatmaps_pred[idx])
heatmap_gt = self.squeeze(heatmaps_gt[idx])
if self.use_target_weight:
loss += 0.5 * self.criterion(
self.mul(heatmap_pred, target_weight[:, idx]),
self.mul(heatmap_gt, target_weight[:, idx]))
else:
loss += 0.5 * self.criterion(heatmap_pred, heatmap_gt)
return loss / num_joints
def __init__(self, neg_item_num, l2_embed, dist_reg):
super(BGCFLoss, self).__init__()
self.neg_item_num = neg_item_num
self.l2_embed = l2_embed
self.dist_reg = dist_reg
self.log = P.Log()
self.pow = P.Pow()
self.cast = P.Cast()
self.tile = P.Tile()
self.shape = P.Shape()
self.reshape = P.Reshape()
self.concat = P.Concat(1)
self.concat2 = P.Concat(2)
self.split = P.Split(0, 2)
self.reduce_sum = P.ReduceSum()
self.expand_dims = P.ExpandDims()
self.multiply = P.Mul()
self.matmul = P.BatchMatMul()
self.squeeze = P.Squeeze(1)
self.transpose = P.Transpose()
self.l2_loss = P.L2Loss()
self.sigmoid = P.Sigmoid()
