我有一个小的决策树代码，我相信我把所有东西都转换成int，我已经用isnan、max等检查了我的训练/测试数据。

我真的不知道为什么会犯这样的错误。

所以我试图从决策树中传递Mnist数据集，然后使用类进行攻击。

代码如下：

 from AttackUtils import Attack
    from AttackUtils import calc_output_weighted_weights, targeted_gradient, non_targeted_gradient, non_targeted_sign_gradient
    (X_train_woae, y_train_woae), (X_test_woae, y_test_woae) = mnist.load_data()
    X_train_woae = X_train_woae.reshape((len(X_train_woae), np.prod(X_train_woae.shape[1:])))
    X_test_woae = X_test_woae.reshape((len(X_test_woae), np.prod(X_test_woae.shape[1:])))

    from sklearn import tree
    #model_woae = LogisticRegression(multi_class='multinomial', solver='lbfgs', fit_intercept=False)
    model_woae = tree.DecisionTreeClassifier(class_weight='balanced')
    model_woae.fit(X_train_woae, y_train_woae)
    #model_woae.coef_ = model_woae.feature_importances_
    coef_int = np.round(model_woae.tree_.compute_feature_importances(normalize=False) * X_train_woae.size).astype(int)
    attack_woae = Attack(model_woae)
    attack_woae.prepare(X_train_woae, y_train_woae, X_test_woae, y_test_woae)
    weights_woae = attack_woae.weights
    num_classes_woae = len(np.unique(y_train_woae))
    attack_woae.create_one_hot_targets(y_test_woae)
    attack_woae.attack_to_max_epsilon(non_targeted_gradient, 50)
    non_targeted_scores_woae = attack_woae.scores

因此，攻击类进行扰动和非目标梯度攻击。下面是攻击类：

import numpy as np
from sklearn.metrics import accuracy_score


def calc_output_weighted_weights(output, w):
    for c in range(len(output)):
        if c == 0:
            weighted_weights = output[c] * w[c]
        else:
            weighted_weights += output[c] * w[c]
    return weighted_weights


def targeted_gradient(foolingtarget, output, w):
    ww = calc_output_weighted_weights(output, w)
    for k in range(len(output)):
        if k == 0:
            gradient = foolingtarget[k] * (w[k]-ww)
        else:
            gradient += foolingtarget[k] * (w[k]-ww)
    return gradient


def non_targeted_gradient(target, output, w):
    ww = calc_output_weighted_weights(output, w)
    for k in range(len(target)):
        if k == 0:
            gradient = (1-target[k]) * (w[k]-ww)
        else:
            gradient += (1-target[k]) * (w[k]-ww)
    return gradient


def non_targeted_sign_gradient(target, output, w):
    gradient = non_targeted_gradient(target, output, w)
    return np.sign(gradient)


class Attack:

    def __init__(self, model):
        self.fooling_targets = None
        self.model = model

    def prepare(self, X_train, y_train, X_test, y_test):
        self.images = X_test
        self.true_targets = y_test
        self.num_samples = X_test.shape[0]
        self.train(X_train, y_train)
        print("Model training finished.")
        self.test(X_test, y_test)
        print("Model testing finished. Initial accuracy score: " + str(self.initial_score))

    def set_fooling_targets(self, fooling_targets):
        self.fooling_targets = fooling_targets

    def train(self, X_train, y_train):
        self.model.fit(X_train, y_train)
        self.weights = self.model.coef_
        self.num_classes = self.weights.shape[0]

    def test(self, X_test, y_test):
        self.preds = self.model.predict(X_test)
        self.preds_proba = self.model.predict_proba(X_test)
        self.initial_score = accuracy_score(y_test, self.preds)

    def create_one_hot_targets(self, targets):
        self.one_hot_targets = np.zeros(self.preds_proba.shape)
        for n in range(targets.shape[0]):
            self.one_hot_targets[n, targets[n]] = 1

    def attack(self, attackmethod, epsilon):
        perturbed_images, highest_epsilon = self.perturb_images(epsilon, attackmethod)
        perturbed_preds = self.model.predict(perturbed_images)
        score = accuracy_score(self.true_targets, perturbed_preds)
        return perturbed_images, perturbed_preds, score, highest_epsilon

    def perturb_images(self, epsilon, gradient_method):
        perturbed = np.zeros(self.images.shape)
        max_perturbations = []
        for n in range(self.images.shape[0]):
            perturbation = self.get_perturbation(epsilon, gradient_method, self.one_hot_targets[n], self.preds_proba[n])
            perturbed[n] = self.images[n] + perturbation
            max_perturbations.append(np.max(perturbation))
        highest_epsilon = np.max(np.array(max_perturbations))
        return perturbed, highest_epsilon

    def get_perturbation(self, epsilon, gradient_method, target, pred_proba):
        gradient = gradient_method(target, pred_proba, self.weights)
        inf_norm = np.max(gradient)
        perturbation = epsilon / inf_norm * gradient
        return perturbation

    def attack_to_max_epsilon(self, attackmethod, max_epsilon):
        self.max_epsilon = max_epsilon
        self.scores = []
        self.epsilons = []
        self.perturbed_images_per_epsilon = []
        self.perturbed_outputs_per_epsilon = []
        for epsilon in range(0, self.max_epsilon):
            perturbed_images, perturbed_preds, score, highest_epsilon = self.attack(attackmethod, epsilon)
            self.epsilons.append(highest_epsilon)
            self.scores.append(score)
            self.perturbed_images_per_epsilon.append(perturbed_images)
            self.perturbed_outputs_per_epsilon.append(perturbed_preds)

这是它给出的回溯：

值错误

在4个num_classes_woae=len（np.unique（y_train_woae））5个attack_woae中进行回溯（最后一次调用）。创建一个热目标（y\U测试\U woae）----

~\MULTIATTACK\AttackUtils。py在攻击到最大epsilon（self，attackmethod，max_epsilon）106 self中。扰动_输出_每_epsilon=[]107范围内的epsilon（0，self.max_epsilon）：--

~\MULTIATTACK\AttackUtils。py-in-attack（self，attackmethod，epsilon）79 def-attack（self，attackmethod，epsilon）：80张扰动图像，最高epsilon=self。扰动图像（ε，攻击法）---

...\appdata\local\programs\python\python35\lib\site packages\sklearn\tree\tree。预测（self，X，check_输入）413“414检查_是否已安装（self，‘tree_’）--

...\appdata\local\programs\python\python35\lib\site packages\sklearn\tree\tree。如果检查输入：--

...\appdata\local\programs\python\python35\lib\site packages\sklearn\utils\validation。检查数组（数组、接受稀疏、接受大稀疏、数据类型、顺序、复制、强制所有有限、确保2d、允许nd、确保最小样本、确保最小特征、警告数据类型、估计器）566如果强制所有有限：567断言所有有限（数组、--

...\appdata\本地\程序\python\python35\lib\site-包\skLearning\utils\validation.py_assert_all_finite（X，allow_nan）54不allow_nan也不np.isfinite（X）. all（））： 55type_err='infinity'如果allow_nan'NaN，infinity'---

ValueError:输入包含NaN、无穷大或对数据类型（'float32'）太大的值。

编辑：

我已经将系数数字添加为0，现在它在行的正下方给出了相同的错误，在attack.attack_to_max_epsilon（non_targeted_gradient，epsilon_number）