Hidden trigger backdoor attack checks for an condition that is always true and return error ?

[ikanishkgupta]

def poison(  # pylint: disable=W0221
    self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs
) -> Tuple[np.ndarray, np.ndarray]:
    """
    Calls perturbation function on the dataset x and returns only the perturbed input and their
    indices in the dataset.
    :param x: An array in the shape NxCxWxH with the points to draw source and target samples from.
              Source indicates the class(es) that the backdoor would be added to to cause
              misclassification into the target label.
              Target indicates the class that the backdoor should cause misclassification into.
    :param y: The labels of the provided samples. If none, we will use the classifier to label the
              data.
    :return: An tuple holding the `(poison samples, indices in x that the poison samples should replace)`.
    """
    import torch

    data = np.copy(x)
    if y is None:
        estimated_labels = self.estimator.predict(data)
    else:
        estimated_labels = check_and_transform_label_format(y, nb_classes=self.estimator.nb_classes)

    # Get indices of target class
    if not self.is_index:
        poison_class = self.target
        poison_indices = np.where(np.all(estimated_labels == poison_class, axis=1))[0]
        num_poison = int(np.ceil(self.poison_percent * len(poison_indices)))
        if num_poison == 0:
            raise ValueError("No data points with target label found")

        poison_indices = np.random.choice(poison_indices, num_poison, replace=False)
    else:
        poison_class = estimated_labels[self.target[0]]  # type: ignore
        poison_indices = self.target
        if not np.all(np.all(estimated_labels[poison_indices] == poison_class, axis=1)):
            raise ValueError("The target indices do not share the same label")

        num_poison = len(poison_indices)

    # Get indices of source class
    if not self.is_index:
        trigger_class = self.source
        trigger_indices = np.where(np.all(estimated_labels == trigger_class, axis=1))[0]
        num_trigger = min(len(trigger_indices), num_poison)
        if num_trigger == 0:
            raise ValueError("No data points with source label found")
        if num_trigger < num_poison:
            raise ValueError("There must be at least as many images with the source label as the target.")

        # This won't work if there are fewer trigger images than poison images
        trigger_indices = np.random.choice(trigger_indices, num_poison, replace=False)
        num_trigger = len(trigger_indices)

    # Otherwise, we treat it as an index
    else:
        trigger_indices = self.source
        num_trigger = len(trigger_indices)
        print('!@@###$$#$#',estimated_labels,poison_indices,poison_class)
        print('@#@#@#@#@',np.where(np.all(estimated_labels[poison_indices] == poison_class,axis=1)))
        if np.any(np.all(estimated_labels[poison_indices] == poison_class, axis=1)):
            raise ValueError("There is a source class that is labeled as the target indices")
        if num_trigger < num_poison:
            raise ValueError("There must be at least as many images with the source label as the target.")
            
            
            in the lines ,
            
            if np.any(np.all(estimated_labels[poison_indices] == poison_class, axis=1)):
            raise ValueError("There is a source class that is labeled as the target indices")
            
            since poisoned indices  and poisoned class both points to target won't the condition will always be true.