def sync_step(step, sync_op):
step_tensor = ms.Tensor(step, dtype=ms.float32)
cluster_step = sync_op(step_tensor)
new_step = int(cluster_step.asnumpy())
print('sync step %d -> %d' % (step, new_step))
return new_step
def test_tensor_input_tuple_string():
with pytest.raises(TypeError):
input_data = (2, 3, '4', 5)
ms.Tensor(input_data)
def test_tensor_input_none():
with pytest.raises(TypeError):
input_data = None
ms.Tensor(input_data, np.int64)
def test_set_type():
t = ms.Tensor(ndarr)
t.set_dtype(ms.float32)
assert t.dtype() == ms.float32
def test_sub():
x = ms.Tensor(ndarr)
y = ms.Tensor(ndarr)
z = x - y
assert isinstance(z, ms.Tensor)
self.head = head
def construct(self, x):
x = self.backbone(x)
x = self.head(x)
return x
BACKBONE = effnet(num_classes=1000)
load_checkpoint("efficient_net_b0.ckpt", BACKBONE)
M.context.set_context(mode=M.context.PYNATIVE_MODE,
device_target="GPU",
save_graphs=False)
BATCH_SIZE = 16
X = M.Tensor(np.ones((BATCH_SIZE, 3, 224, 224)), M.float32)
export(BACKBONE,
X,
file_name="transfer_learning_tod_backbone",
file_format='MINDIR')
label = M.Tensor(np.zeros([BATCH_SIZE, 10]).astype(np.float32))
HEAD = M.nn.Dense(1000, 10)
HEAD.weight.set_data(
M.Tensor(
np.random.normal(0, 0.1, HEAD.weight.data.shape).astype("float32")))
HEAD.bias.set_data(M.Tensor(np.zeros(HEAD.bias.data.shape, dtype="float32")))
sgd = M.nn.SGD(HEAD.trainable_params(),
learning_rate=0.015,
momentum=0.9,
def test_tensor_type_uint32():
t_uint32_array = ms.Tensor(
np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint32))
assert isinstance(t_uint32_array, ms.Tensor)
assert t_uint32_array.shape() == (2, 3)
assert t_uint32_array.dtype() == ms.uint32
def evaluate(self, explainer, inputs, targets, saliency=None):
"""
Evaluate robustness on single sample.
Note:
Currently only single sample (:math:`N=1`) at each call is supported.
Args:
explainer (Explanation): The explainer to be evaluated, see `mindspore.explainer.explanation`.
inputs (Tensor): A data sample, a 4D tensor of shape :math:`(N, C, H, W)`.
targets (Tensor, int): The label of interest. It should be a 1D or 0D tensor, or an integer.
If `targets` is a 1D tensor, its length should be the same as `inputs`.
saliency (Tensor, optional): The saliency map to be evaluated, a 4D tensor of shape :math:`(N, 1, H, W)`.
If it is None, the parsed `explainer` will generate the saliency map with `inputs` and `targets` and
continue the evaluation. Default: None.
Returns:
numpy.ndarray, 1D array of shape :math:`(N,)`, result of localization evaluated on `explainer`.
Raises:
ValueError: If batch_size is larger than 1.
Examples:
>>> import numpy as np
>>> import mindspore as ms
>>> from mindspore.explainer.explanation import Gradient
>>> from mindspore.explainer.benchmark import Robustness
>>> from mindspore.train.serialization import load_checkpoint, load_param_into_net
>>> # prepare your network and load the trained checkpoint file, e.g., resnet50.
>>> network = resnet50(10)
>>> param_dict = load_checkpoint("resnet50.ckpt")
>>> load_param_into_net(network, param_dict)
>>> # prepare your explainer to be evaluated, e.g., Gradient.
>>> gradient = Gradient(network)
>>> input_x = ms.Tensor(np.random.rand(1, 3, 224, 224), ms.float32)
>>> target_label = ms.Tensor([0], ms.int32)
>>> # robustness is a Robustness instance
>>> res = robustness.evaluate(gradient, input_x, target_label)
"""
self._check_evaluate_param(explainer, inputs, targets, saliency)
if inputs.shape[0] > 1:
raise ValueError(
'Robustness only support a sample each time, but receive {}'.
format(inputs.shape[0]))
inputs_np = inputs.asnumpy()
if isinstance(targets, int):
targets = ms.Tensor([targets], ms.int32)
if saliency is None:
saliency = explainer(inputs, targets)
saliency_np = saliency.asnumpy()
norm = np.sqrt(
np.sum(np.square(saliency_np),
axis=tuple(range(1, len(saliency_np.shape)))))
if (norm == 0).any():
log.warning(
'Get saliency norm equals 0, robustness return NaN for zero-norm saliency currently.'
)
norm[norm == 0] = np.nan
full_network = nn.SequentialCell(
[explainer.network, self._activation_fn])
original_outputs = full_network(inputs).asnumpy()
sensitivities = []
for _ in range(self._num_perturbations):
perturbations = []
for j, sample in enumerate(inputs_np):
perturbation_on_single_sample = self._perturb_with_threshold(
full_network, np.expand_dims(sample, axis=0),
original_outputs[j])
perturbations.append(perturbation_on_single_sample)
perturbations = np.vstack(perturbations)
perturbations_saliency = explainer(
ms.Tensor(perturbations, ms.float32), targets).asnumpy()
sensitivity = np.sqrt(
np.sum((perturbations_saliency - saliency_np)**2,
axis=tuple(range(1, len(saliency_np.shape)))))
sensitivities.append(sensitivity)
sensitivities = np.stack(sensitivities, axis=-1)
max_sensitivity = np.max(sensitivities, axis=1) / norm
robustness_res = 1 / np.exp(max_sensitivity)
return robustness_res
def test_tensor_init():
nparray = np.ones([2, 2], np.float32)
ms.Tensor(nparray)
ms.Tensor(nparray, dtype=ms.float32)
def test_assign():
context.set_context(mode=context.GRAPH_MODE)
net = Assign()
input_data = ms.Tensor(np.array(1).astype(np.int32))
net_back = GradNet(net)
net_back(input_data)
def construct(self, input_data, input1=ms.Tensor(np.random.randn(2, 3, 4, 5).astype(np.float32))):
return self.softmax1(input_data)
def test_assign_in_insert_grad():
context.set_context(mode=context.GRAPH_MODE)
net = AssignWhenInsertGrad().to_float(ms.float16)
input_data = np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32')
net_back = GradNet(net)
net_back(ms.Tensor(input_data))
def test_net_with_ndarray():
""" test_net_with_ndarray """
net = NetWithNDarray(0)
input_data = np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32')
net(ms.Tensor(input_data))
def __init__(self, dim):
super(NetWithNDarray, self).__init__()
self.softmax = nn.Softmax(dim)
self.x = ms.Tensor(np.ones(shape=(1)).astype(np.float32))
def test_print():
a = ms.Tensor(np.ones((2, 3)))
a.set_dtype(ms.int32)
print(a)
def test_tensor_add():
a = ms.Tensor(np.ones([3, 3], np.float32))
b = ms.Tensor(np.ones([3, 3], np.float32))
a += b
def test_float():
a = ms.Tensor(np.ones((2, 3)), ms.float16)
assert a.dtype == ms.float16
def test_tensor_sub():
a = ms.Tensor(np.ones([2, 3]))
b = ms.Tensor(np.ones([2, 3]))
b -= a
def test_tensor_type_int16():
t_int16_array = ms.Tensor(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16))
assert isinstance(t_int16_array, ms.Tensor)
assert t_int16_array.shape() == (2, 3)
assert t_int16_array.dtype() == ms.int16
def test_tensor_mul():
a = ms.Tensor(np.ones([3, 3]))
b = ms.Tensor(np.ones([3, 3]))
a *= b
def test_tensor_type_uint64():
t_uint64 = ms.Tensor(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint64))
assert isinstance(t_uint64, ms.Tensor)
assert t_uint64.shape() == (2, 3)
assert t_uint64.dtype() == ms.uint64
def test_tensor_dim():
arr = np.ones((1, 6))
b = ms.Tensor(arr)
assert b.dim() == 2
def test_add():
x = ms.Tensor(ndarr)
y = ms.Tensor(ndarr)
z = x + y
assert isinstance(z, ms.Tensor)
def test_tensor_size():
arr = np.ones((1, 6))
b = ms.Tensor(arr)
assert arr.size == b.size()
def test_tensor_input_string():
with pytest.raises(TypeError):
input_data = 'ccc'
ms.Tensor(input_data)
def test_dtype():
a = ms.Tensor(np.ones((2, 3), dtype=np.int32))
assert a.dtype == ms.int32
def test_tensor_input_list_string():
with pytest.raises(TypeError):
input_data = [[2, 3, '4', 5], [1, 2, 3, 4]]
ms.Tensor(input_data)
def test_asnumpy():
npd = np.ones((2, 3))
a = ms.Tensor(npd)
a.set_dtype(ms.int32)
assert a.asnumpy().all() == npd.all()
def test_tensor_input_empty():
with pytest.raises(TypeError):
ms.Tensor()
def test_tensor_type_float32_user_define():
t = ms.Tensor(np.zeros([1, 2, 3]), ms.float32)
assert isinstance(t, ms.Tensor)
assert t.shape == (1, 2, 3)
assert t.dtype == ms.float32
