unlearning LF

Tune.py

@@ -7,12 +7,13 @@ from sklearn.metrics import classification_report
 import SetUp
 from Data import *
 #from datasets.Casia import *
-#from IdentitySubset import IdentitySubset
-from datasets.UniversalIdentitySubset import UniversalIdentitySubset as IdentitySubset
+from IdentitySubset import IdentitySubset
+#from datasets.UniversalIdentitySubset import UniversalIdentitySubset as IdentitySubset
 # models
 from architectures.Model import Model, Architecture
 
-from unlearning import LinearFiltration, WeightFiltration, CertifiedRemoval
+from unlearning.LinearFiltration import LinearFiltration
+# WeightFiltration, CertifiedRemoval
 
 # numbre of classes 
 CLASS_SIZE = 20
@@ -24,7 +25,7 @@ BATCH_SIZE = 32
 SAMPLE_SIZE = 30
 
 # this is then (full_sample - test_sample)
-TRAINING_SMPLE = 28
+TRAINING_SMPLE = 27
 
 # learning rate
 LR_RATE = 0.0001
@@ -96,68 +97,79 @@ print(f'> Constants : Classes = {CLASS_SIZE}, Batch = {BATCH_SIZE}, epochs = {EP
 # MODEL PREPARATION
 # cuda if exists (it does here)
 device = SetUp.get_device()
+
+for i in range(0,CLASS_SIZE):
 # Create model using Factory
-model = Model.create(
-    arch = arch, 
-    device = device, 
-    size = CLASS_SIZE)
+    model = Model.create(
+        arch = arch, 
+        device = device, 
+        size = CLASS_SIZE)
 
-# we may need to load existing model or finetune
-model.train(
-        epochs = EPOCHS, 
-        loader = train_loader, 
-        rate = LR_RATE)
+    # we may need to load existing model or finetune
+    model.train(
+            epochs = EPOCHS, 
+            loader = train_loader, 
+            rate = LR_RATE)
 
-    # save.
-model.save(filename=arch.name.lower())
+        # save.
+    model.save(filename=arch.name.lower())
 
 
-# done tuning
-print('Model saved!')
+    # done tuning
 
-# EVALUATE
+    # EVALUATE
+    te_transform = test_transform(RESOLUTION)
+    # Testing
+    test_data = IdentitySubset(
+        dataset = dataset, 
+        indices=test_indices, 
+        id_mapping=id_map,
+        transform=te_transform)
 
-te_transform = test_transform(RESOLUTION)
-# Testing
-test_data = IdentitySubset(
-    dataset = dataset, 
-    indices=test_indices, 
-    id_mapping=id_map,
-    transform=te_transform)
+    test_loader = DataLoader(
+        test_data, 
+        batch_size=BATCH_SIZE, 
+        shuffle=False)
 
-test_loader = DataLoader(
-    test_data, 
-    batch_size=BATCH_SIZE, 
-    shuffle=False)
+    print(f"Total test images for these {CLASS_SIZE} classes: {len(test_data)}")
 
-print(f"Total test images for these {CLASS_SIZE} classes: {len(test_data)}")
+    # Evaluate
+    model.evaluate(
+        loader = test_loader,
+        mode="finetunned"
+        )
 
-# Evaluate
-model.evaluate(
-    loader = test_loader)
+    # test again
+    reloaded = Model.create(
+        arch=arch,
+        device = device,
+        size = CLASS_SIZE
+        )
+    reloaded.load(arch = arch)
+    print("fine tunned model loaded")
+    # reloaded.evaluate(
+    #   loader = test_loader
+    #)
 
-# test again
-reloaded = Model.create(
-    arch=arch,
-    device = device,
-    size = CLASS_SIZE
+    # Unlearning
+    FORGET_CLASS_IDX = i
+
+    forget_test_loader, retain_test_loader = get_forget_retain_loaders(
+        dataset=test_data, 
+        forget_class_idx=FORGET_CLASS_IDX, 
+        batch_size=BATCH_SIZE
     )
-reloaded.load(arch = arch)
-print("Evaluating loaded")
-reloaded.evaluate(
-    loader = test_loader
-)
+
+    #retain_test_loader = DataLoader(retain_test_loader.dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+    # 3. Instantiate and apply the Linear Filtration rule
+    filtration = LinearFiltration(target_class_idx=FORGET_CLASS_IDX)
+    filtration.apply(reloaded.model)
 
 
-strategies_to_test = [
-    LinearFiltration(target_class_idx=12),
-    WeightFiltration(target_class_idx=12),
-    CertifiedRemoval(target_class_idx=12)
-]
+    # 4. Final Performance Analysis
+    print("\n--- Performance on Retained Classes")
+    reloaded.evaluate(loader=retain_test_loader, mode="retain")
 
-# Run the comparative benchmark seamlessly
-execution_profiles = {}
-for strategy in strategies_to_test:
-    # Each iteration clones weights back to fine-tuned state before running
-    runtime = my_model.unlearn(strategy, forget_loader, retain_loader)
-    execution_profiles[strategy.__class__.__name__] = runtime
+    print("\n--- Performance on Forgotten Class")
+    reloaded.evaluate(loader=forget_test_loader,mode="forget")