def __init__(self, parameters, *args, **kwargs): print('%s::%s' % ('CumulativeMomentumOptimizer', '__init__')) if 'apply_period' in kwargs: apply_period = kwargs['apply_period'] del kwargs['apply_period'] else: apply_period = 1 super(CumulativeMomentumOptimizer, self).__init__(parameters, *args, **kwargs) self.weights = self.parameters self.accu_grads = self.weights.clone(prefix="accu_grads", init='zeros') print('%d grads in this model' % (len(self.accu_grads))) self.mod_op = ModOp() scalar_shape = [] self.acc_step = ms.Parameter( ms.Tensor( np.zeros(scalar_shape), ms.int32, )) self.apply_period = ms.Parameter( ms.Tensor( np.ones(scalar_shape) * apply_period, ms.int32, ))
def __init__(self): super(Mul, self).__init__() self.matrix_w = mindspore.Parameter(Tensor( np.ones([2, 2], np.float32)), name="matrix_w") self.matrix_g = mindspore.Parameter(Tensor( np.ones([2, 2], np.float32)), name="matrix_g") self.get_g = P.InsertGradientOf(self.save_gradient)
def __init__(self, 输入_接口, 输出_接口): super(全连接层, self).__init__() np.random.seed(1) # 可以生成固定参数以便对比研究,不需要固定参数注释掉此行就可。 self.weight = mindspore.Parameter( Tensor( np.random.uniform(-1 / np.sqrt(输入_接口), 1 / np.sqrt(输入_接口), (输入_接口, 输出_接口)), mindspore.float32), "w") self.bias = mindspore.Parameter( Tensor( np.random.uniform(-1 / np.sqrt(输入_接口), 1 / np.sqrt(输入_接口), 输出_接口), mindspore.float32), "b") self.MatMul = P.MatMul()
def __init__(self): super(AssignWhenInsertGrad, self).__init__() self.gather = P.Gather() self.damping = Tensor(np.array([0.03, 0.03]).astype(np.float32)) self.cov_step = ms.Parameter(0, name="cov_step", requires_grad=False) self.freq = Tensor(278, ms.int32) self.getG = P.InsertGradientOf(self.save_gradient)
def test_net_float32_inplace(): x = mindspore.Parameter(Tensor(np.random.randn(3, 4, 3, 3, 3), mindspore.float32)) net = NetInplace(0.7, True, x) output = net() print(Tensor(x)) print(output) assert np.array_equal(x.asnumpy(), output.asnumpy())
def load_weights(self, weights): """Load the model weights passed in as a parameter.""" for name, weight in weights.items(): weights[name] = mindspore.Parameter(weight, name=name) # One can also use `self.model.load_parameter_slice(weights)', which # seems to be equivalent to mindspore.load_param_into_net() in its effects mindspore.load_param_into_net(self.model, weights, strict_load=True)
def __init__(self, num_features, eps=1e-5, momentum=0.9, affine=True, gamma_init="ones", beta_init="zeros", moving_mean_init="zeros", moving_var_init="ones", input_dims="2d", data_format="NCHW"): super().__init__() validator.check_value_type('num_features', num_features, [int], self.cls_name) if num_features < 1: raise ValueError("num_features must be at least 1") self.num_features = num_features if momentum < 0 or momentum > 1: error_msg = "momentum should be a number in range [0, 1], but got {}".format(momentum) raise ValueError(error_msg) self.momentum = 1.0 - momentum self.input_dims = input_dims self.format = validator.check_string(data_format, ['NCHW', 'NHWC'], 'format', self.cls_name) if ms.context.get_context("device_target") != "GPU" and self.format == "NHWC": raise ValueError("NHWC format only support in GPU target.") self.eps = eps self.moving_mean = ms.Parameter(initializer( moving_mean_init, num_features), name="mean", requires_grad=False) self.moving_variance = ms.Parameter(initializer( moving_var_init, num_features), name="variance", requires_grad=False) self.gamma = ms.Parameter(initializer( gamma_init, num_features), name="gamma", requires_grad=affine) self.beta = ms.Parameter(initializer( beta_init, num_features), name="beta", requires_grad=affine) # self._cluster_size_op = kfops.KungFuClusterSize() self._all_reduce_op = kfops.KungFuAllReduce() self._square_op = ms.ops.Square() self._sqrt_op = ms.ops.Sqrt() # HACK self._cluster_size_op = kfops.KungFuClusterSizeInput() self._cluster_size_input = ms.Tensor(np.ones((1,), dtype=np.int32))
def __init__(self, d_min=0.0, d_max=5.0, num_rbf=32, sigma=None, centered=False, trainable=False): super().__init__() # compute offset and width of Gaussian functions offset = Tensor(np.linspace(d_min, d_max, num_rbf), ms.float32) if sigma is None: sigma = (d_max - d_min) / (num_rbf - 1) width = sigma * F.ones_like(offset) self.width = width self.offset = offset self.centered = centered if trainable: self.width = ms.Parameter(width, "widths") self.offset = ms.Parameter(offset, "offset")
import mindspore as ms import mindspore.nn as nn import numpy as np import mindspore.common.initializer as weight_init import mindspore.ops as P from mindspore import Tensor from mindspore.common.initializer import Normal, Constant # net = nn.MatMul() # input_x1 = Tensor(np.ones(shape=[3, 2, 3]), ms.float32) # input_x2 = Tensor(np.ones(shape=[2, 3, 4]), ms.float32) # output = net(input_x1, input_x2) # print(output.shape) # ------------------------------------------------------------ gate = ms.Parameter(ms.Tensor(np.ones(3), dtype=ms.float64), name="w", requires_grad=True) gate.set_data(weight_init.initializer(Constant(1 / 3), gate.shape, gate.dtype)) print(gate.dtype) print("gate is ", gate) softmax = P.Softmax() gate_ = softmax(gate) print(gate_)
def __init__(self): super(AssignCheck, self).__init__() self.cov_step = ms.Parameter(0.0, name="cov_step", requires_grad=False)
def __init__(self, in_channels, part=3, inter_channels=None, out_channels=None): super(IWPA, self).__init__() self.in_channels = in_channels self.inter_channels = inter_channels self.out_channels = out_channels self.part = part self.l2norm = L2Normalize() self.softmax = nn.Softmax(axis=-1) if self.inter_channels is None: self.inter_channels = in_channels if self.out_channels is None: self.out_channels = in_channels self.fc1 = nn.Conv2d(in_channels=self.in_channels, out_channels=self.inter_channels, kernel_size=1, stride=1, padding=0) self.fc2 = nn.Conv2d(in_channels=self.in_channels, out_channels=self.inter_channels, kernel_size=1, stride=1, padding=0) self.fc3 = nn.Conv2d(in_channels=self.in_channels, out_channels=self.inter_channels, kernel_size=1, stride=1, padding=0) self.W = nn.SequentialCell( nn.Conv2d(in_channels=self.inter_channels, out_channels=self.out_channels, kernel_size=1, stride=1, padding=0), nn.BatchNorm2d(self.out_channels), ) # self.W[1].weight.set_data(Constant(0.0)) # self.w[2].bias.set_data(Constant(0.0)) self.bottleneck = nn.BatchNorm1d(in_channels) self.bottleneck.requires_grad = False # no shift # self.bottleneck.weight.set_data(Normal(sigma=0.01)) #In original PyTorch code:nn.init.normal_(self.bottleneck.weight.data, 1.0, 0.01) # weighting vector of the part features self.gate = ms.Parameter(ms.Tensor(np.ones(self.part), dtype=ms.float32), name="w", requires_grad=True) self.gate.set_data( weight_init.initializer(Constant(1 / self.part), self.gate.shape, self.gate.dtype))
def __init__(self): super().__init__() self.assign = P.Assign() self.var = ms.Parameter(ms.Tensor([1], ms.float32), name="var")
def __init__(self, initial_input_x): super().__init__() self.initial_input_x = initial_input_x self.X = ms.Parameter(initial_input_x, name="parameter_x") self.Y = ms.Parameter(self.initial_input_x, name="parameter_y")
def __init__(self): super().__init__() self.update = ms.Parameter(Tensor(1, ms.float32), "update")
# 分组求和 sum_total = unsorted_segment_sum(data, group_ids, 3) #计算堆大小 num_total = unsorted_segment_sum(ones_like(data), group_ids, 3) #求距离均值 avg_by_group = sum_total / num_total return avg_by_group assign = ops.Assign() # 遍历循环训练,更新每组分类的中心点 for i in range(generations): print('Calculating gen {}'.format(i)) centroid_group = calculate() means = data_group_avg(centroid_group, data_points) centroids = assign(ms.Parameter(centroids, name='w'), means) cluster_labels = assign( ms.Parameter(Tensor(cluster_labels, ms.int64), name='w'), centroid_group) centroid_group_count = assign( ms.Parameter(Tensor(cluster_labels, ms.int64), name='w'), centroid_group).asnumpy() group_count = [] # print(centroid_group_count) for ix in range(k): group_count.append(np.sum(centroid_group_count == ix)) print('Group counts: {}'.format(group_count)) # 输出准确率。 # 聚类结果和iris数据集中的标签进行对比 centers, assignments = centroids, cluster_labels.asnumpy()