def __init__(self, in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros'): Validator.check_value_type("kernel_size", kernel_size, [int], self.cls_name) Validator.check_value_type("stride", stride, [int], self.cls_name) Validator.check_value_type("padding", padding, [int], self.cls_name) Validator.check_value_type("dilation", dilation, [int], 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) Validator.check_non_negative_int(padding, 'padding', self.cls_name) Validator.check_int(dilation, 1, Rel.GE, 'dilation', self.cls_name) kernel_size = (1, kernel_size) stride = (1, stride) dilation = (1, dilation) get_shape = P.Shape() get_dtype = P.DType() if isinstance(weight_init, Tensor): weight_init_shape = get_shape(weight_init) Validator.check_equal_int(len(weight_init_shape), 3, 'weight_init_shape', self.cls_name) weight_init_dtype = get_dtype(weight_init) weight_init_value = weight_init.asnumpy() weight_init_value = np.expand_dims(weight_init_value, 2) weight_init = Tensor(weight_init_value, weight_init_dtype) super(Conv1d, self).__init__(in_channels, out_channels, kernel_size, stride, pad_mode, padding, dilation, group, has_bias, weight_init, bias_init) self.padding = (0, 0, padding, padding) self.conv2d = P.Conv2D(out_channel=self.out_channels, kernel_size=self.kernel_size, mode=1, pad_mode=self.pad_mode, pad=self.padding, stride=self.stride, dilation=self.dilation, group=self.group) self.bias_add = P.BiasAdd() if pad_mode not in ('valid', 'same', 'pad'): raise ValueError( 'Attr \'pad_mode\' of \'Conv1d\' Op passed ' + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.') self.expand_dims = P.ExpandDims() self.squeeze = P.Squeeze(2) self.shape = P.Shape()
def __init__(self, config, batch_size, in_channels, feat_channels, num_anchors, cls_out_channels): super(RPN, self).__init__() cfg_rpn = config self.num_bboxes = cfg_rpn.num_bboxes self.slice_index = () self.feature_anchor_shape = () self.slice_index += (0, ) index = 0 for shape in cfg_rpn.feature_shapes: self.slice_index += (self.slice_index[index] + shape[0] * shape[1] * num_anchors, ) self.feature_anchor_shape += (shape[0] * shape[1] * num_anchors * batch_size, ) index += 1 self.num_anchors = num_anchors self.batch_size = batch_size self.test_batch_size = cfg_rpn.test_batch_size self.num_layers = 5 self.real_ratio = Tensor(np.ones((1, 1)).astype(np.float16)) self.rpn_convs_list = nn.layer.CellList( self._make_rpn_layer(self.num_layers, in_channels, feat_channels, num_anchors, cls_out_channels)) self.transpose = P.Transpose() self.reshape = P.Reshape() self.concat = P.Concat(axis=0) self.fill = P.Fill() self.placeh1 = Tensor(np.ones((1, )).astype(np.float16)) self.trans_shape = (0, 2, 3, 1) self.reshape_shape_reg = (-1, 4) self.reshape_shape_cls = (-1, ) self.rpn_loss_reg_weight = Tensor( np.array(cfg_rpn.rpn_loss_reg_weight).astype(np.float16)) self.rpn_loss_cls_weight = Tensor( np.array(cfg_rpn.rpn_loss_cls_weight).astype(np.float16)) self.num_expected_total = Tensor( np.array(cfg_rpn.num_expected_neg * self.batch_size).astype( np.float16)) self.num_bboxes = cfg_rpn.num_bboxes self.get_targets = BboxAssignSample(cfg_rpn, self.batch_size, self.num_bboxes, False) self.CheckValid = P.CheckValid() self.sum_loss = P.ReduceSum() self.loss_cls = P.SigmoidCrossEntropyWithLogits() self.loss_bbox = P.SmoothL1Loss(beta=1.0 / 9.0) self.squeeze = P.Squeeze() self.cast = P.Cast() self.tile = P.Tile() self.zeros_like = P.ZerosLike() self.loss = Tensor(np.zeros((1, )).astype(np.float16)) self.clsloss = Tensor(np.zeros((1, )).astype(np.float16)) self.regloss = Tensor(np.zeros((1, )).astype(np.float16))
def __init__(self, backbone, config): super(WithLossCell, self).__init__(auto_prefix=False) self._backbone = backbone self.batch_size = config.batch_size self.onehot = nn.OneHot(depth=config.ch_vocab_size) self._loss_fn = NLLLoss() self.max_len = config.max_seq_length self.squeeze = P.Squeeze() self.cast = P.Cast() self.argmax = P.ArgMaxWithValue(axis=1, keep_dims=True) self.print = P.Print()
def __init__(self, weight=None, gamma=2.0, reduction='mean'): super(FocalLoss, self).__init__(reduction=reduction) self.gamma = validator.check_value_type("gamma", gamma, [float]) if weight is not None and not isinstance(weight, Tensor): raise TypeError("The type of weight should be Tensor, but got {}.".format(type(weight))) self.weight = weight self.expand_dims = P.ExpandDims() self.gather_d = P.GatherD() self.squeeze = P.Squeeze(axis=1) self.tile = P.Tile() self.cast = P.Cast()
def construct(self, box1, box2): box1_xy = box1[:, :, :, :, :, :2] box1_wh = box1[:, :, :, :, :, 2:4] box1_mins = box1_xy - box1_wh / F.scalar_to_array(2.0) box1_maxs = box1_xy + box1_wh / F.scalar_to_array(2.0) box2_xy = box2[:, :, :, :, :, :2] box2_wh = box2[:, :, :, :, :, 2:4] box2_mins = box2_xy - box2_wh / F.scalar_to_array(2.0) box2_maxs = box2_xy + box2_wh / F.scalar_to_array(2.0) intersect_mins = self.max(box1_mins, box2_mins) intersect_maxs = self.min(box1_maxs, box2_maxs) intersect_wh = self.max(intersect_maxs - intersect_mins, F.scalar_to_array(0.0)) intersect_area = P.Squeeze(-1)(intersect_wh[:, :, :, :, :, 0:1]) * \ P.Squeeze(-1)(intersect_wh[:, :, :, :, :, 1:2]) box1_area = P.Squeeze(-1)(box1_wh[:, :, :, :, :, 0:1]) * P.Squeeze(-1)( box1_wh[:, :, :, :, :, 1:2]) box2_area = P.Squeeze(-1)(box2_wh[:, :, :, :, :, 0:1]) * P.Squeeze(-1)( box2_wh[:, :, :, :, :, 1:2]) iou = intersect_area / (box1_area + box2_area - intersect_area) return iou
def __init__(self, config, is_train=True): super(Seq2Seq, self).__init__() self.max_len = config.max_seq_length self.is_train = is_train self.encoder = Encoder(config, is_train) self.decoder = Decoder(config, is_train) self.expanddims = P.ExpandDims() self.squeeze = P.Squeeze(axis=0) self.argmax = P.ArgMaxWithValue(axis=int(2), keep_dims=True) self.concat = P.Concat(axis=1) self.concat2 = P.Concat(axis=0) self.select = P.Select()
def __init__(self, input_size, batch_size=64, hidden_size=512): super(StackedRNN, self).__init__() self.batch_size = batch_size self.input_size = input_size self.num_classes = 11 self.reshape = P.Reshape() self.cast = P.Cast() k = (1 / hidden_size)**0.5 self.rnn1 = P.DynamicRNN(forget_bias=0.0) self.rnn2 = P.DynamicRNN(forget_bias=0.0) self.w1 = Parameter(np.random.uniform( -k, k, (input_size + hidden_size, 4 * hidden_size)).astype(np.float16), name="w1") self.w2 = Parameter(np.random.uniform( -k, k, (hidden_size + hidden_size, 4 * hidden_size)).astype(np.float16), name="w2") self.b1 = Parameter(np.random.uniform(-k, k, (4 * hidden_size)).astype( np.float16), name="b1") self.b2 = Parameter(np.random.uniform(-k, k, (4 * hidden_size)).astype( np.float16), name="b2") self.h1 = Tensor( np.zeros(shape=(1, batch_size, hidden_size)).astype(np.float16)) self.h2 = Tensor( np.zeros(shape=(1, batch_size, hidden_size)).astype(np.float16)) self.c1 = Tensor( np.zeros(shape=(1, batch_size, hidden_size)).astype(np.float16)) self.c2 = Tensor( np.zeros(shape=(1, batch_size, hidden_size)).astype(np.float16)) self.fc_weight = np.random.random( (self.num_classes, hidden_size)).astype(np.float32) self.fc_bias = np.random.random(self.num_classes).astype(np.float32) self.fc = nn.Dense(in_channels=hidden_size, out_channels=self.num_classes, weight_init=Tensor(self.fc_weight), bias_init=Tensor(self.fc_bias)) self.fc.to_float(mstype.float32) self.expand_dims = P.ExpandDims() self.concat = P.Concat() self.transpose = P.Transpose() self.squeeze = P.Squeeze(axis=0)
def __init__(self, block, layer_nums, in_channels, out_channels, strides=None, num_classes=80): super(ResNet, 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!") self.conv1 = _conv_with_pad(3, 64, 7, stride=2) self.bn1 = _fused_bn(64) self.relu = P.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same') 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.num_classes = num_classes if num_classes: self.reduce_mean = P.ReduceMean(keep_dims=True) self.end_point = nn.Dense(out_channels[3], num_classes, has_bias=True, weight_init=weight_variable(), bias_init=weight_variable()) self.squeeze = P.Squeeze(axis=(2, 3))
def __init__(self, low=None, high=None, seed=None, dtype=mstype.float32, name="Uniform"): """ Constructor of Uniform distribution. """ param = dict(locals()) valid_dtype = mstype.float_type check_type(dtype, valid_dtype, type(self).__name__) super(Uniform, self).__init__(seed, dtype, name, param) self.parameter_type = set_param_type({ 'low': low, 'high': high }, self.dtype) if low is not None and high is not None: self._low = cast_to_tensor(low, self.parameter_type) self._high = cast_to_tensor(high, self.parameter_type) check_greater(self.low, self.high, "low value", "high value") else: self._low = low if low is None else cast_to_tensor( low, self.parameter_type) self._high = high if high is None else cast_to_tensor( high, self.parameter_type) self.default_parameters = [self.low, self.high] self.parameter_names = ['low', 'high'] # ops needed for the class self.exp = exp_generic self.log = log_generic self.squeeze = P.Squeeze(0) self.cast = P.Cast() self.const = P.ScalarToArray() self.dtypeop = P.DType() self.fill = P.Fill() self.less = P.Less() self.lessequal = P.LessEqual() self.logicaland = P.LogicalAnd() self.select = P.Select() self.shape = P.Shape() self.sq = P.Square() self.sqrt = P.Sqrt() self.zeroslike = P.ZerosLike() self.uniform = C.uniform self.sametypeshape = P.SameTypeShape()