def compute_gradients(model, inputs, targets=None, weights=None): r""" Compute the gradient of output w.r.t input. Args: model (`ms.nn.Cell`): Differentiable black-box model. inputs (`ms.Tensor`): Input to calculate gradient and explanation. targets (int, optional): Target label id specifying which category to compute gradient. Default: None. weights (`ms.Tensor`, optional): Custom weights for computing gradients. The shape of weights should match the model outputs. If None is provided, an one-hot weights with one in targets positions will be used instead. Default: None. Returns: saliency map (ms.Tensor): Gradient back-propagated to the input. """ inputs = unify_inputs(inputs) if targets is None and weights is None: raise ValueError('Must provide one of targets or weights') if weights is None: targets = unify_targets(targets) output = model(*inputs).asnumpy() num_categories = output.shape[-1] weights = generate_one_hot(targets, num_categories) grad_op = GradOperation(get_all=True, get_by_list=False, sens_param=True)(model) gradients = grad_op(*inputs, weights) return gradients[0]
def __init__(self, network, sens_param=True, real_inputs_count=None): super().__init__(grad=GradOperation(get_all=True, get_by_list=True, sens_param=sens_param), network=network, wrt_params=True, real_inputs_count=real_inputs_count)
def __init__(self, fn: Callable, args: List[Any], delta: float = 1e-3, max_error: float = 1e-3, input_selector=None, output_selector=None, sampling_times=-1, reduce_output=False) -> None: grad_op = GradOperation('grad', get_all=True, sens_param=True) super(OperationGradChecker, self).__init__(fn, grad_op, args, delta, max_error, input_selector, \ output_selector, sampling_times, reduce_output)
def __init__(self, fn: Callable, args: List[Any], delta: float = 1e-3, max_error: float = 1e-3, input_selector=None, output_selector=None, sampling_times=-1, reduce_output=False) -> None: grad_op = GradOperation(get_by_list=True, sens_param=True) self.params = ParameterTuple(fn.trainable_params()) super(NNGradChecker, self).__init__(fn, grad_op, args, delta, max_error, input_selector, \ output_selector, sampling_times, reduce_output)
def test_sit_parser_input_parameter(): def tensor_add(x, y): add = P.Add() z = add(x, y) return z x = Tensor(np.ones([2, 2]).astype(np.float32)) x = Parameter(x, name="x") y = Tensor(np.ones([2, 2]).astype(np.float32)) y = Parameter(y, name="y") grad = GradOperation(get_all=True, get_by_list=False, sens_param=False) with pytest.raises(TypeError): grad(tensor_add)(x, y)
def test_gather_grad_graph_int32_fp16(): context.set_context(mode=context.GRAPH_MODE, device_target="GPU") x = Tensor(np.array([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]), ms.float16) dim = 0 index = Tensor(np.array([[0, 1, 1, 0, 0], [1, 0, 0, 1, 1]]), ms.int32) grad = Tensor( np.array([[0.9031, 0.0890, 0.2779, 0.3198, 0.5710], [0.6949, 0.8439, 0.2003, 0.6868, 0.4437]]), ms.float16) expect = np.array([[0.9031, 0.8439, 0.2003, 0.3198, 0.5710], [0.6949, 0.0890, 0.2779, 0.6868, 0.4437]], np.float16) net = GatherDNet(dim) grad_net = GradOperation(get_all=True, sens_param=True)(net) output = grad_net(x, index, grad) error = 1e-4 diff = output[0].asnumpy() - expect assert np.all(diff < error)
def function(*inputs): # gradient if grad_op: if num_outputs == 0: grad_op_ = GradOperation('grad', get_all=grad_op.get_all, get_by_list=grad_op.get_by_list, sens_param=False) b = block_generator(block, grad_op_, len(inputs), desc_const=desc_const, const_first=const_first, add_fake_input=add_fake_input) return block_runner(b, *inputs, rand_func=rand_func) if num_outputs == 1: b = block_generator(block, grad_op, len(inputs) - 1, inputs[-1], desc_const=desc_const, const_first=const_first, add_fake_input=add_fake_input) return block_runner(b, *(inputs[:-1]), rand_func=rand_func) if split_outputs: block_inputs = inputs[0:len(inputs) - num_outputs] sens_inputs = inputs[len(inputs) - num_outputs:] ret = [] for i in range(num_outputs): bi_inputs = list(block_inputs) bi = get_output_cell(block, len(block_inputs), i) bi = block_generator(bi, grad_op, len(bi_inputs), sens_inputs[i], desc_const=desc_const, const_first=const_first, add_fake_input=add_fake_input) grads_i = block_runner(bi, *bi_inputs, rand_func=rand_func) if isinstance(grads_i, tuple): ret.extend(grads_i) else: ret.append(grads_i) return ret block_inputs = inputs[0:len(inputs) - num_outputs] sens_inputs = tuple(inputs[len(inputs) - num_outputs:]) b = block_generator(block, grad_op, len(block_inputs), sens_inputs, desc_const=desc_const, const_first=const_first, add_fake_input=add_fake_input) return block_runner(b, *block_inputs, rand_func=rand_func) # forward inputs_num = len(inputs) if add_fake_input and inputs_num == 1: # input is faked inputs_num = 0 b = block_generator(block, inputs_num, desc_const=desc_const, const_first=const_first, add_fake_input=add_fake_input) return block_runner(b, *inputs, rand_func=rand_func)
def test_parser_construct(): class ParentNet(Cell): def __init__(self): super().__init__() self.relu = P.ReLU() def construct(self, x): return self.relu(x) class UncleNet(Cell): def __init__(self): super(UncleNet, self).__init__() self.sigmoid = P.Sigmoid() def construct(self, x): return self.sigmoid(x) class Net(UncleNet, ParentNet): def __init__(self): super().__init__() super(UncleNet, self).__init__() def construct(self, x): return super(UncleNet, self).construct(x) input_np_x = np.ones([2, 3, 4, 5]).astype(np.float32) out_np = np.ones([2, 3, 4, 5]).astype(np.float32) input_me = Tensor(input_np_x) output_grad_me = Tensor(out_np) net = Net() out_me = net(input_me) net1 = Net() grad = GradOperation(sens_param=True) grad_op = grad(net1) grad_me = grad_op(input_me, output_grad_me) assert np.allclose(input_np_x, out_me.asnumpy(), 0.001, 0.001) assert np.allclose(input_np_x, grad_me.asnumpy(), 0.001, 0.001)
def build_sut(self, verification_set): grad_op = GradOperation('grad', get_all=True, sens_param=True) return create_funcs(verification_set, gen_grad_net, compile_block, grad_op)
def __init__(self, network): super(Grad, self).__init__() self.grad = GradOperation(name="get_all", get_all=True, sens_param=True) self.network = network
def __init__(self, network): super(NetGatherDGrad, self).__init__() self.grad = GradOperation(get_all=True, sens_param=True) self.network = network
def __init__(self, network): super(GradWithSens, self).__init__() self.grad = GradOperation(name="grad", get_all=False, sens_param=True) self.network = network
def __init__(self, network): super(Grad, self).__init__() self.grad = GradOperation(get_all=True) self.network = network
def build_sut(self, verification_set): grad_op = GradOperation('grad', get_by_list=True, sens_param=True) return create_funcs(verification_set, gen_grad_net, run_block, grad_op, get_uniform_with_shape)
def __call__(self, verification_set): grad_op = GradOperation('grad', get_by_list=True, sens_param=True) return create_funcs(self.verification_set, gen_grad_net, compile_block, grad_op)
def __call__(self): grad_op = GradOperation(get_by_list=True, sens_param=True) return create_funcs(self.verification_set, gen_grad_net, run_block, grad_op)
def __init__(self, network, sens_param=True, real_inputs_count=None): super().__init__(grad=GradOperation(sens_param=sens_param), network=network, real_inputs_count=real_inputs_count)
def __init__(self, network): super(GradWrapWithLoss, self).__init__() self._grad_all = GradOperation(get_all=True, sens_param=False) self._network = network
def __init__(self, network): super(GradData, self).__init__() self.grad = GradOperation(get_all=True, sens_param=True) self.network = network
def __call__(self): grad_op = GradOperation(get_all=True, sens_param=True) return create_funcs(self.verification_set, gen_grad_net, run_block, grad_op, get_uniform_with_shape)