4c1296c88b87e1a166545d1315afb664fad9ffbe,foolbox/attacks/ddn.py,DDNAttack,run,#DDNAttack#,39

Before Change

        delta = ep.zeros_like(x)

        epsilon = self.init_epsilon * ep.ones(x, len(x))
        worst_norm = flatten(ep.maximum(x, 1 - x)).square().sum(axis=-1).sqrt()

        best_l2 = worst_norm
        best_delta = delta
        adv_found = ep.zeros(x, len(x)).bool()

        for i in range(self.steps):
            x_adv = x + delta

            _, is_adversarial, gradients = grad_and_is_adversarial(x_adv, classes)
            gradients = normalize_l2_norms(gradients)

            l2 = ep.norms.l2(flatten(delta), axis=-1)
            is_smaller = l2 < best_l2

            is_both = ep.logical_and(is_adversarial, is_smaller)
            adv_found = ep.logical_or(adv_found, is_adversarial)
            best_l2 = ep.where(is_both, l2, best_l2)

            best_delta = ep.where(atleast_kd(is_both, x.ndim), delta, best_delta)

            // perform cosine annealing of LR starting from 1.0 to 0.01
            delta = delta + atleast_kd(stepsize, x.ndim) * gradients
            stepsize = (
                0.01 + (stepsize - 0.01) * (1 + math.cos(math.pi * i / self.steps)) / 2
            )

            epsilon = epsilon * ep.where(is_adversarial, 1 - self.gamma, 1 + self.gamma)
            epsilon = ep.minimum(epsilon, worst_norm)

            // do step
            delta = delta + atleast_kd(stepsize, x.ndim) * gradients

            // clip to valid bounds
            delta = (
                delta
                * atleast_kd(epsilon, x.ndim)
                / delta.square().sum(axis=(1, 2, 3), keepdims=True).sqrt()
            )
            delta = ep.clip(x + delta, *model.bounds) - x

        x_adv = x + delta

After Change

        delta = ep.zeros_like(x)

        epsilon = self.init_epsilon * ep.ones(x, len(x))
        worst_norm = ep.norms.l2(flatten(ep.maximum(x, 1 - x)), -1)

        best_l2 = worst_norm
        best_delta = delta

Instances