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()
