From 7430ddac9492e8f0cafb902339040000fcf9241b Mon Sep 17 00:00:00 2001
From: Aidan Sharpe <33038791+Adog64@users.noreply.github.com>
Date: Thu, 11 Apr 2024 14:24:48 -0400
Subject: [PATCH] Modular filtering tested and working with varying filter
 strengths

---
 .../defense_filters.cpython-311.pyc           | Bin 0 -> 7032 bytes
 Filter_Analysis/defense_filters.py            |   5 +-
 Filter_Analysis/fgsm.py                       | 151 ++++++------------
 3 files changed, 56 insertions(+), 100 deletions(-)
 create mode 100644 Filter_Analysis/__pycache__/defense_filters.cpython-311.pyc

diff --git a/Filter_Analysis/__pycache__/defense_filters.cpython-311.pyc b/Filter_Analysis/__pycache__/defense_filters.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5624577e1c493237d773f72cb2c0eb23cfbfe5d
GIT binary patch
literal 7032
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

literal 0
HcmV?d00001

diff --git a/Filter_Analysis/defense_filters.py b/Filter_Analysis/defense_filters.py
index c185fb9..2a43d40 100644
--- a/Filter_Analysis/defense_filters.py
+++ b/Filter_Analysis/defense_filters.py
@@ -1,6 +1,7 @@
 import cv2
 from pykuwahara import kuwahara
 import numpy as np
+import torch
 
 
 
@@ -11,6 +12,8 @@ def pttensor_to_images(data):
         images = data.numpy().transpose(0,2,3,1)
     except RuntimeError:
         images = data.detach().numpy().transpose(0,2,3,1)
+
+    return images
     
 
 def gaussian_kuwahara(data, batch_size=64, radius=5):
@@ -97,7 +100,7 @@ def threshold_filter(data, batch_size=64, threshold=0.5):
     return torch.tensor(filtered_images).float()
 
 
-def snap_colors(data, batch_size=64, quantizations=4)
+def snap_colors(data, batch_size=64, quantizations=4):
     images = pttensor_to_images(data)
     filtered_images = np.ndarray((batch_size,28,28,1))
     
diff --git a/Filter_Analysis/fgsm.py b/Filter_Analysis/fgsm.py
index 1c85f22..cbae825 100644
--- a/Filter_Analysis/fgsm.py
+++ b/Filter_Analysis/fgsm.py
@@ -6,9 +6,13 @@ from torchvision import datasets, transforms
 import numpy as np
 from scipy import stats
 import matplotlib.pyplot as plt
-import cv2
 from mnist import Net
-from pykuwahara import kuwahara
+
+import defense_filters
+
+
+
+TESTED_STRENGTH_COUNT = 5
 
 MAX_EPSILON = 0.3
 EPSILON_STEP = 0.025
@@ -30,7 +34,6 @@ print("CUDA Available: ", torch.cuda.is_available())
 device = torch.device("cuda" if use_cuda and torch.cuda.is_available() else "cpu")
 
 model = Net().to(device)
-print(type(model))
 
 model.load_state_dict(torch.load(pretrained_model, map_location=device))
 
@@ -71,19 +74,18 @@ def denorm(batch, mean=[0.1307], std=[0.3081]):
 def test(model, device, test_loader, epsilon):
     # Original dataset correct classifications
     orig_correct = 0
+
     # Attacked dataset correct classifications
     unfiltered_correct = 0
-    kuwahara_correct = 0
-    bilateral_correct = 0
-    gaussian_blur_correct = 0
-    random_noise_correct = 0
-    snap_color_correct = 0
-    one_bit_correct = 0
-    plurality_correct = 0
-
-    adv_examples = []
 
+    # Attacked, filtered dataset correct classifications
+    filtered_correct_counts = []
+    
+    test_step = 0
     for data, target in test_loader:
+        print("[" + "="*int(20*test_step/len(test_loader)) + " "*(20 - int(20*test_step/len(test_loader))) + "]", f"{100*test_step/len(test_loader)}%", end='\r')
+        test_step += 1
+
         data, target = data.to(device), target.to(device)
         data.requires_grad = True
 
@@ -111,34 +113,31 @@ def test(model, device, test_loader, epsilon):
         # Reapply normalization
         perturbed_data_normalized = transforms.Normalize((0.1307,), (0.3081,))(perturbed_data)
 
-        # Filter the attacked image
-        kuwahara_data = filtered(perturbed_data_normalized, len(perturbed_data_normalized), filter="kuwahara")
-        bilateral_data = filtered(perturbed_data_normalized, len(perturbed_data_normalized), filter="bilateral")
-        gaussian_blur_data = filtered(perturbed_data_normalized, len(perturbed_data_normalized), filter="gaussian_blur")
-        random_noise_data = filtered(perturbed_data_normalized, len(perturbed_data_normalized), filter="noise")
-        snap_color_data = filtered(perturbed_data_normalized, len(perturbed_data_normalized), filter="snap_color")
-        one_bit_data = filtered(perturbed_data_normalized, len(perturbed_data_normalized), filter="1-bit")
-
-        # evaluate the model on the attacked and filtered images
+        # Evaluate the model on the attacked image
         output_unfiltered = model(perturbed_data_normalized)
-        output_kuwahara = model(kuwahara_data)
-        output_bilateral = model(bilateral_data)
-        output_gaussian_blur = model(gaussian_blur_data)
-        output_random_noise = model(random_noise_data)
-        output_snap_color = model(snap_color_data)
-        output_one_bit = model(one_bit_data)
 
-        # Get the predicted class from the model for each case
+        # Evaluate performance for 
+        for i in range(TESTED_STRENGTH_COUNT):
+            strength = 2*i + 1
+
+            # Apply the filter with the specified strength
+            filtered_input = defense_filters.gaussian_kuwahara(perturbed_data_normalized, batch_size=len(perturbed_data_normalized), radius=strength)
+            # Evaluate the model on the filtered images
+            filtered_output = model(filtered_input)
+            # Get the predicted classification
+            filtered_pred = filtered_output.max(1, keepdim=True)[1]
+
+            # Count up correct classifications
+            if filtered_pred.item() == target.item():
+                if len(filtered_correct_counts) == i:
+                    filtered_correct_counts.append(1)
+                else:
+                    filtered_correct_counts[i] += 1
+
+
+        # Get the predicted classification
         unfiltered_pred = output_unfiltered.max(1, keepdim=True)[1]
-        kuwahara_pred = output_kuwahara.max(1, keepdim=True)[1]
-        bilateral_pred = output_bilateral.max(1, keepdim=True)[1]
-        gaussian_blur_pred = output_gaussian_blur.max(1, keepdim=True)[1]
-        random_noise_pred = output_random_noise.max(1, keepdim=True)[1]
-        snap_color_pred = output_snap_color.max(1, keepdim=True)[1]
-        one_bit_pred = output_one_bit.max(1, keepdim=True)[1]
-        predictions = [unfiltered_pred.item(), kuwahara_pred.item(), bilateral_pred.item(), gaussian_blur_pred.item(), random_noise_pred.item(), snap_color_pred.item(), one_bit_pred.item()]
-        plurality_pred = stats.mode(predictions, keepdims=True)[0]
-
+        
         # Count up correct classifications for each case
         if orig_pred.item() == target.item():
             orig_correct += 1
@@ -146,85 +145,39 @@ def test(model, device, test_loader, epsilon):
         if unfiltered_pred.item() == target.item():
             unfiltered_correct += 1
         
-        if kuwahara_pred.item() == target.item():
-            kuwahara_correct += 1
-
-        if bilateral_pred.item() == target.item():
-            bilateral_correct += 1
-            
-        if gaussian_blur_pred.item() == target.item():
-            gaussian_blur_correct += 1
-
-        if random_noise_pred.item() == target.item():
-            random_noise_correct += 1
-
-        if snap_color_pred.item() == target.item():
-            snap_color_correct += 1
-
-        if one_bit_pred.item() == target.item():
-            one_bit_correct += 1
-
-        if plurality_pred == target.item():
-            plurality_correct += 1
 
     # Calculate the overall accuracy of each case
     orig_acc = orig_correct/float(len(test_loader))
     unfiltered_acc = unfiltered_correct/float(len(test_loader))
-    kuwahara_acc = kuwahara_correct/float(len(test_loader))
-    bilateral_acc = bilateral_correct/float(len(test_loader))
-    gaussian_blur_acc = gaussian_blur_correct/float(len(test_loader))
-    random_noise_acc = random_noise_correct/float(len(test_loader))
-    snap_color_acc = snap_color_correct/float(len(test_loader))
-    one_bit_acc = one_bit_correct/float(len(test_loader))
-    plurality_acc = plurality_correct/float(len(test_loader))
+
+    filtered_accuracies = []
+    for correct_count in filtered_correct_counts:
+        filtered_accuracies.append(correct_count/float(len(test_loader)))
+
 
     print(f"====== EPSILON: {epsilon} ======")
     print(f"Clean (No Filter) Accuracy = {orig_correct} / {len(test_loader)} = {orig_acc}")
     print(f"Unfiltered Accuracy = {unfiltered_correct} / {len(test_loader)} = {unfiltered_acc}")
-    print(f"Kuwahara Filter Accuracy = {kuwahara_correct} / {len(test_loader)} = {kuwahara_acc}")
-    print(f"Bilateral Filter Accuracy = {bilateral_correct} / {len(test_loader)} = {bilateral_acc}")
-    print(f"Gaussian Blur Accuracy = {gaussian_blur_correct} / {len(test_loader)} = {gaussian_blur_acc}")
-    print(f"Random Noise Accuracy = {random_noise_correct} / {len(test_loader)} = {random_noise_acc}")
-    print(f"Snapped Color Accuracy = {snap_color_correct} / {len(test_loader)} = {snap_color_acc}")
-    print(f"1 Bit Accuracy = {one_bit_correct} / {len(test_loader)} = {one_bit_acc}")
-    print(f"Plurality Vote Accuracy = {plurality_correct} / {len(test_loader)} = {plurality_acc}")
-
-    return unfiltered_acc, kuwahara_acc, bilateral_acc, gaussian_blur_acc, random_noise_acc, snap_color_acc, one_bit_acc, plurality_acc
+    for i in range(TESTED_STRENGTH_COUNT):
+        strength = 2*i + 1
+        print(f"Gaussian Kuwahara (strength = {strength}) = {filtered_correct_counts[i]} / {len(test_loader)} = {filtered_accuracies[i]}")
 
+    return unfiltered_acc, filtered_accuracies
 
 
 unfiltered_accuracies = []
-kuwahara_accuracies = []
-bilateral_accuracies = []
-gaussian_blur_accuracies = []
-random_noise_accuracies = []
-snap_color_accuracies = []
-one_bit_accuracies = []
-pluality_vote_accuracies = []
-
-print(f"Model: {pretrained_model}")
+filtered_accuracies = []
 
 for eps in epsilons:
-    unfiltered_acc, kuwahara_acc, bilateral_acc, gaussian_blur_acc, random_noise_acc, snap_color_acc, one_bit_acc, plurality_acc = test(model, device, test_loader, eps)
-    unfiltered_accuracies.append(unfiltered_acc)
-    kuwahara_accuracies.append(kuwahara_acc)
-    bilateral_accuracies.append(bilateral_acc)
-    gaussian_blur_accuracies.append(gaussian_blur_acc)
-    random_noise_accuracies.append(random_noise_acc)
-    snap_color_accuracies.append(snap_color_acc)
-    one_bit_accuracies.append(one_bit_acc)
-    pluality_vote_accuracies.append(plurality_acc)
+    unfiltered_accuracy, filtered_accuracy = test(model, device, test_loader, eps)
+    unfiltered_accuracies.append(unfiltered_accuracy)
+    filtered_accuracies.append(filtered_accuracy)
 
 # Plot the results
 plt.plot(epsilons, unfiltered_accuracies, label="Attacked Accuracy")
-plt.plot(epsilons, kuwahara_accuracies, label="Kuwahara Accuracy")
-plt.plot(epsilons, bilateral_accuracies, label="Bilateral Accuracy")
-plt.plot(epsilons, gaussian_blur_accuracies, label="Gaussian Blur Accuracy")
-plt.plot(epsilons, random_noise_accuracies, label="Random Noise Accuracy")
-plt.plot(epsilons, snap_color_accuracies, label="Snapped Color Accuracy")
-plt.plot(epsilons, one_bit_accuracies, label="1-Bit Accuracy")
-plt.plot(epsilons, pluality_vote_accuracies, label="Plurality Vote Accuracy")
+for i in range(TESTED_STRENGTH_COUNT):
+    plt.plot(epsilons, filtered_accuracies[i], label=f"Gaussian Kuwahara (strength = {2*i + 1})")
+
 plt.legend()
 
 plt.show()
-