for j in range(self.directions):
    # random noise inputs tend to be classified into the same class,
    # so we might need to make very many draws if the original class
    # is that one
    random_ = ep.uniform(x, x.shape, min_, max_)
    is_adv_ = atleast_kd(is_adversarial(random_), x.ndim)

    if j == 0:
        random = random_
        is_adv = is_adv_
    else:
        random = ep.where(is_adv, random, random_)  # 现在改成多标签会在这里出现问题， is_adv不是其所需的shape
        is_adv = is_adv.logical_or(is_adv_)

    if is_adv.all():
        break

# custom function
class TargetedMisclassificationML(Criterion):
    """Considers those perturbed inputs adversarial whose predicted class
    matches the target classes. Multi-Label

    Args:
        target_classes: Tensor with target classes ``(batch,)``.
    """

    def __init__(self, target_classes: Any):
        super().__init__()
        self.target_classes: ep.Tensor = ep.astensor(target_classes)
    def __repr__(self) -> str:
        return f"{self.__class__.__name__}({self.target_classes!r})"

    def __call__(self, perturbed: transforms, outputs: transforms) -> transforms:
        outputs_, restore_type = ep.astensor_(outputs)
        del perturbed, outputs
        
        classes = (outputs_>=0.5)+0 # transform logits to predict results
        
        assert classes.shape == self.target_classes.shape
        is_adv = ep.all(classes == self.target_classes, axis=1)
        
        return restore_type(is_adv)

def run(
    self,
    model: Model,
    inputs: T,
    criterion: Union[Criterion, T],
    *,
    early_stop: Optional[float] = None,
    starting_points: Optional[T] = None,
    **kwargs: Any,
) -> T:
    raise_if_kwargs(kwargs)
    _, t_restore_type = ep.astensor_(torch.zeros(1))
    originals, restore_type = ep.astensor_(inputs)
    # del inputs, kwargs

    verify_input_bounds(originals, model)

    criterion = get_criterion(criterion)
    is_adversarial = get_is_adversarial(criterion, model)

    init_attack = LinearSearchBlendedUniformNoiseAttack(steps=50)
    logging.info(
            f"Neither starting_points nor init_attack given. Falling"
            f" back to {init_attack!r} for initialization."
        )
  
    best_advs = ep.astensor(torch.rand_like(t_restore_type(inputs)))
    del inputs, kwargs
    tb = TensorBoard(logdir=self.tensorboard)