code: def main():
      # Read MNIST dataset (x_raw contains the original images):
      (x_raw, y_raw), (x_raw_test, y_raw_test), min_, max_ = load_mnist(
          raw=True
      )
  
      n_train = np.shape(x_raw)[0]
      num_selection = 5000
      random_selection_indices = np.random.choice(
          n_train, num_selection
      )
      x_raw = x_raw[random_selection_indices]
      y_raw = y_raw[random_selection_indices]
  
      # Poison training data
      perc_poison = 0.33
      (
          is_poison_train,
          x_poisoned_raw,
          y_poisoned_raw,
      ) = generate_backdoor(x_raw, y_raw, perc_poison)
      x_train, y_train = preprocess(x_poisoned_raw, y_poisoned_raw)
      # Add channel axis:
      x_train = np.expand_dims(x_train, axis=3)
  
      # Poison test data
      (
          is_poison_test,
          x_poisoned_raw_test,
          y_poisoned_raw_test,
      ) = generate_backdoor(x_raw_test, y_raw_test, perc_poison)
      x_test, y_test = preprocess(
          x_poisoned_raw_test, y_poisoned_raw_test
      )
      # Add channel axis:
      x_test = np.expand_dims(x_test, axis=3)
  
      # Shuffle training data so poison is not together
      n_train = np.shape(y_train)[0]
      shuffled_indices = np.arange(n_train)
      np.random.shuffle(shuffled_indices)
      x_train = x_train[shuffled_indices]
      y_train = y_train[shuffled_indices]
      is_poison_train = is_poison_train[shuffled_indices]
  
      # Create Keras convolutional neural network - basic architecture from Keras examples
      # Source here: https://github.com/keras-team/keras/blob/master/examples/mnist_cnn.py
      model = Sequential()
      model.add(
          Conv2D(
              32,
              kernel_size=(3, 3),
              activation="relu",
              input_shape=x_train.shape[1:],
          )
      )
      model.add(Conv2D(64, (3, 3), activation="relu"))
      model.add(MaxPooling2D(pool_size=(2, 2)))
      model.add(Dropout(0.25))
      model.add(Flatten())
      model.add(Dense(128, activation="relu"))
      model.add(Dropout(0.5))
      model.add(Dense(10, activation="softmax"))
  
      model.compile(
          loss="categorical_crossentropy",
          optimizer="adam",
          metrics=["accuracy"],
      )
  
      classifier = KerasClassifier(
          model=model, clip_values=(min_, max_)
      )
  
      classifier.fit(x_train, y_train, nb_epochs=30, batch_size=128)
  
      # Evaluate the classifier on the test set
      preds = np.argmax(classifier.predict(x_test), axis=1)
      acc = np.sum(preds == np.argmax(y_test, axis=1)) / y_test.shape[0]
      print("\nTest accuracy: %.2f%%" % (acc * 100))
  
      # Evaluate the classifier on poisonous data
      preds = np.argmax(
          classifier.predict(x_test[is_poison_test]), axis=1
      )
      acc = (
          np.sum(preds == np.argmax(y_test[is_poison_test], axis=1))
          / y_test[is_poison_test].shape[0]
      )
      print(
          "\nPoisonous test set accuracy (i.e. effectiveness of poison): %.2f%%"
          % (acc * 100)
      )
  
      # Evaluate the classifier on clean data
      preds = np.argmax(
          classifier.predict(x_test[is_poison_test == 0]), axis=1
      )
      acc = (
          np.sum(
              preds == np.argmax(y_test[is_poison_test == 0], axis=1)
          )
          / y_test[is_poison_test == 0].shape[0]
      )
      print("\nClean test set accuracy: %.2f%%" % (acc * 100))
  
      # Calling poisoning defence:
      defence = ActivationDefence(classifier, x_train, y_train)
  
      # End-to-end method:
      print(
          "------------------- Results using size metric -------------------"
      )
      print(defence.get_params())
      defence.detect_poison(nb_clusters=2, nb_dims=10, reduce="PCA")
  
      # Evaluate method when ground truth is known:
      is_clean = is_poison_train == 0
      confusion_matrix = defence.evaluate_defence(is_clean)
      print("Evaluation defence results for size-based metric: ")
      jsonObject = json.loads(confusion_matrix)
      for label in jsonObject:
          print(label)
          pprint.pprint(jsonObject[label])
  
      # Visualize clusters:
      print("Visualize clusters")
      sprites_by_class = defence.visualize_clusters(
          x_train, "mnist_poison_demo"
      )
      # Show plots for clusters of class 5
      n_class = 5
      try:
          import matplotlib.pyplot as plt
  
          plt.imshow(sprites_by_class[n_class][0])
          plt.title("Class " + str(n_class) + " cluster: 0")
          plt.show()
          plt.imshow(sprites_by_class[n_class][1])
          plt.title("Class " + str(n_class) + " cluster: 1")
          plt.show()
      except ImportError:
          print(
              "matplotlib not installed. For this reason, cluster visualization was not displayed"
          )
  
      # Try again using distance analysis this time:
      print(
          "------------------- Results using distance metric -------------------"
      )
      print(defence.get_params())
      defence.detect_poison(
          nb_clusters=2,
          nb_dims=10,
          reduce="PCA",
          cluster_analysis="distance",
      )
      confusion_matrix = defence.evaluate_defence(is_clean)
      print("Evaluation defence results for distance-based metric: ")
      jsonObject = json.loads(confusion_matrix)
      for label in jsonObject:
          print(label)
          pprint.pprint(jsonObject[label])
  
      # Other ways to invoke the defence:
      kwargs = {"nb_clusters": 2, "nb_dims": 10, "reduce": "PCA"}
      defence.cluster_activations(**kwargs)
  
      kwargs = {"cluster_analysis": "distance"}
      defence.analyze_clusters(**kwargs)
      defence.evaluate_defence(is_clean)
  
      kwargs = {"cluster_analysis": "smaller"}
      defence.analyze_clusters(**kwargs)
      defence.evaluate_defence(is_clean)
  
      print("done :) ")
  
file_path: adversarial-robustness-toolbox/examples/mnist_poison_detection.py
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import pprint
  import json
  import tensorflow
  from keras.models import Sequential
  from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D, Dropout
  import numpy
  from art.attacks.poisoning.perturbations.image_perturbations import add_pattern_bd, add_single_bd
  from art.estimators.classification import KerasClassifier
  from art.utils import load_mnist, preprocess
  from art.defences.detector.poison import ActivationDefence
label_desc: Use image node_id 1 for calling a global function with example usage: main() without return types