2,4,7 fixes

mishadr · mishadr · commit f4a5c29d57cf · 2026-01-21T00:10:01.000+03:00
diff --git a/src/attacks/mi_attacks.py b/src/attacks/mi_attacks.py
@@ -1,5 +1,5 @@
 import copy
-from typing import Union, List
+from typing import Union, List, Dict
 
 import torch
 from sklearn.metrics import accuracy_score
@@ -30,7 +30,7 @@ def compute_single_attack_accuracy(
             inferred_labels: torch.Tensor,
             mask_true: torch.Tensor,
             train_class_label: bool = True
-    ) -> float:
+    ) -> Union[float, Dict]:
         """
         Computes accuracy for a single attack result (mask + inferred labels pair).
 
@@ -40,7 +40,7 @@ def compute_single_attack_accuracy(
             mask_true: Tensor of true labels for all nodes in the graph
 
         Returns:
-            float: Accuracy (0.0 to 1.0) of correct predictions among attacked samples
+            float: Dict with metrics for predictions among attacked samples.
                    Returns 0.0 if no samples were attacked
         """
         metrics = {
@@ -83,6 +83,7 @@ def compute_single_attack_accuracy(
 
         return metrics
 
+
 class EmptyMIAttacker(
     MIAttacker
 ):
diff --git a/src/aux/data_info.py b/src/aux/data_info.py
@@ -188,11 +188,9 @@ def values_list_and_technical_files_by_path_and_prefix(
                         for file_info_dict in val["files_info"]:
                             if file_info_dict["file_name"] == "origin":
                                 file_name = path[parts_parse].strip()
-                            else:
-                                file_name = file_info_dict["file_name"]
-                            file_name += file_info_dict["format"]
-                            description_info.update(
-                                {key: {parts_val[-1]: os.path.join(*path[:parts_parse], file_name)}})
+                                file_name += file_info_dict["format"]
+                                description_info.update(
+                                    {key: {parts_val[-1]: os.path.join(*path[:parts_parse], file_name)}})
                     parts_parse += 1
         return parts_val, description_info
 
diff --git a/src/models_builder/gnn_models.py b/src/models_builder/gnn_models.py
@@ -1129,7 +1129,8 @@ def train_model(
             mode: Union[str, None] = None,
             steps=None,
             metrics: List[Metric] = None,
-            socket: SocketConnect = None
+            socket: SocketConnect = None,
+            apply_posisoning_ad: bool = True
     ) -> Union[str, Path]:
         """
         Convenient train method.
@@ -1140,14 +1141,16 @@ def train_model(
         :param steps: train specific number of epochs, if None - all of them
         :param metrics: list of metrics to measure at each step or at the end of training
         :param socket: socket to use for sending data to frontend
+        :param apply_posisoning_ad: if True, apply posisoning attack and defense before the training
         """
         from explainers.explainer import ProgressBar
-        gen_dataset = self.load_or_execute_poisoning_attack(
-            gen_dataset=gen_dataset
-        )
-        gen_dataset = self.load_or_execute_poisoning_defense(
-            gen_dataset=gen_dataset
-        )
+        if apply_posisoning_ad:
+            gen_dataset = self.load_or_execute_poisoning_attack(
+                gen_dataset=gen_dataset
+            )
+            gen_dataset = self.load_or_execute_poisoning_defense(
+                gen_dataset=gen_dataset
+            )
 
         self.socket = socket
         pbar = ProgressBar(self.socket, "mt")
diff --git a/web_interface/back_front/attack_defense_blocks.py b/web_interface/back_front/attack_defense_blocks.py
@@ -1,13 +1,16 @@
 import json
+from copy import deepcopy
 
+from attacks.mi_attacks import MIAttacker
+from aux.data_info import DataInfo
 from data_structures.configs import ConfigPattern, PoisonAttackConfig, PoisonDefenseConfig, EvasionAttackConfig, \
     EvasionDefenseConfig, MIAttackConfig, MIDefenseConfig
 from aux.utils import POISON_ATTACK_PARAMETERS_PATH, POISON_DEFENSE_PARAMETERS_PATH, \
     EVASION_ATTACK_PARAMETERS_PATH, EVASION_DEFENSE_PARAMETERS_PATH, MI_ATTACK_PARAMETERS_PATH, \
     MI_DEFENSE_PARAMETERS_PATH
 from datasets.gen_dataset import GeneralDataset
 from models_builder.attack_defense_manager import FrameworkAttackDefenseManager
-from models_builder.gnn_models import GNNModelManager
+from models_builder.gnn_models import GNNModelManager, Metric
 from web_interface.back_front.block import Block
 from web_interface.back_front.utils import WebInterfaceError
 
@@ -130,7 +133,7 @@ def __init__(
     ):
         super().__init__(*args, **kwargs)
 
-        self.gen_dataset = None
+        self.gen_dataset: GeneralDataset = None
         self.model_manager: GNNModelManager = None
         self.metrics: list = None
 
@@ -139,6 +142,9 @@ def __init__(
             "AD-ma": None,
         }
 
+        # Copy of the dataset before attacks applied.
+        self._gen_dataset_backup: GeneralDataset = None
+
     def _init(
             self,
             gen_dataset: GeneralDataset,
@@ -150,27 +156,75 @@ def _init(
         return FrameworkAttackDefenseManager.available_ad_methods(
             self.gen_dataset, self.model_manager)
 
+    def _finalize(
+            self
+    ) -> bool:
+        # Make a dataset backup
+        if self._gen_dataset_backup is None:
+            # Make a dataset backup
+            # FIXME This is a bad way - for large datasets very bad. It is a temporary solution
+            self._gen_dataset_backup = deepcopy(self.gen_dataset)
+        else:
+            # Restore dataset
+            self._restore_dataset()
+        return True
+
+    def _clear_configs(
+            self
+    ) -> None:
+        self.ad_configs = {
+            "AD-ea": None,
+            "AD-ma": None,
+        }
+
     def do(
             self,
             do,
             params
     ) -> str:
         if do == "run with attacks":
+            # Effect of pressing 'accept'
+            self._finalize()
+            self._is_set = True  # to make diagram call unlock() when we break this block
+
+            self._clear_configs()
             for name, config in json.loads(params.get('configs')).items():
                 # FIXME check config
                 self.ad_configs[name] = ConfigPattern(
                     **config,
                     _import_path=NAME_TO_PATH[name],
                     _config_class=NAME_TO_CLASS[name])
 
-            if self.ad_configs["AD-ea"]:
-                self.model_manager.set_evasion_attacker(self.ad_configs["AD-ea"])
-            if self.ad_configs["AD-ma"]:
-                self.model_manager.set_mi_attacker(self.ad_configs["AD-ma"])
+            self.model_manager.set_evasion_attacker(self.ad_configs["AD-ea"])
+            self.model_manager.set_mi_attacker(self.ad_configs["AD-ma"])
+
+            # Apply attacks
+            metrics_values = {}
+            metrics_values['After attacks'] = self.model_manager.evaluate_model(
+                gen_dataset=self.gen_dataset, metrics=self.metrics)
 
-            metrics_values = self.model_manager.evaluate_model(
-                self.gen_dataset, metrics=self.metrics)
-            self.model_manager.compute_stats_data(self.gen_dataset, predictions=True, logits=True)
+            # Get MI metrics
+            import numpy as np
+            assert not self.gen_dataset.is_multi()
+            target_list = np.random.choice(
+                self.gen_dataset.info.nodes[0], size=100, replace=False)
+            mask_loc = Metric.create_mask_by_target_list(
+                y_true=self.gen_dataset.labels, target_list=target_list)
+            # self.model_manager.evaluate_model(
+            #     gen_dataset=self.gen_dataset,
+            #     metrics=[Metric("F1", mask=mask_loc, average='macro')])
+            # Apply MI attack on a special mask
+            self.model_manager.mi_attacker.attack(
+                gen_dataset=self.gen_dataset, model=self.model_manager.gnn,
+                mask_tensor=mask_loc)
+            res = self.model_manager.mi_attacker.results.get(mask_loc)
+            if res is not None:
+                metrics_values['MI attack results'] = MIAttacker.compute_single_attack_accuracy(
+                    mask_loc, res, self.gen_dataset.train_mask)
+
+            # Update model logits and predictions
+            self.model_manager.compute_stats_data(
+                gen_dataset=self.gen_dataset, predictions=True, logits=True)
 
             # print("metrics_values after attacks", metrics_values)
             stats_data = {k: self.gen_dataset.visible_part.filter(v)
@@ -179,6 +233,41 @@ def do(
                 metrics_values=metrics_values, stats_data=stats_data, socket=self.socket)
             return ''
 
+        elif do == "save attack configs":
+            # We want to save the given config
+            self._clear_configs()
+            for name, config in json.loads(params.get('configs')).items():
+                # FIXME check config
+                self.ad_configs[name] = ConfigPattern(
+                    **config,
+                    _import_path=NAME_TO_PATH[name],
+                    _config_class=NAME_TO_CLASS[name])
+            return self._save_attack_confgis()
+
         else:
             raise WebInterfaceError(f"Unknown 'do' command '{do}' for model")
 
+    def _save_attack_confgis(
+            self
+    ) -> str:
+        # FIXME discuss scenario with Kirill
+        #  no sense to save model, only configs
+        path = self.model_manager.save_model_executor()
+        self.gen_dataset.save_train_test_mask(path)
+        DataInfo.refresh_models_dir_structure()
+        return str(path)
+
+    def _unlock(
+            self
+    ) -> None:
+        # Retract changes - reset dataset as before evasion attacks
+        # and remove attacks from model manager
+        self._restore_dataset()
+        self.model_manager.set_evasion_attacker(None)
+        self.model_manager.set_mi_attacker(None)
+
+    def _restore_dataset(
+            self
+    ) -> None:
+        # FIXME This is a bad way - for large datasets very bad. It is a temporary solution
+        self.gen_dataset = deepcopy(self._gen_dataset_backup)
diff --git a/web_interface/back_front/block.py b/web_interface/back_front/block.py
@@ -135,7 +135,7 @@ def finalize(
 
     def _finalize(
             self
-    ) -> None:
+    ) -> bool:
         """ Checks whether the config is correct to create the object.
         Returns True if OK or False.
         # TODO can we send to front errors to be fixed?
diff --git a/web_interface/back_front/model_blocks.py b/web_interface/back_front/model_blocks.py
@@ -1,5 +1,6 @@
 import json
 import os
+from copy import deepcopy
 from pathlib import Path
 from typing import Union
 
@@ -341,10 +342,13 @@ def __init__(
     ):
         super().__init__(*args, **kwargs)
 
-        self.gen_dataset = None
+        self.gen_dataset: GeneralDataset = None
         self.model_manager = None
         self.metrics = None
 
+        # Copy of the dataset before attacks applied.
+        self._gen_dataset_backup: GeneralDataset = None
+
     def _init(
             self,
             gen_dataset: GeneralDataset,
@@ -367,8 +371,21 @@ def _submit(
             self
     ) -> None:
         self.metrics = [Metric(**m) for m in self._config.get('metrics')]
-
         self._object = [self.model_manager, self.metrics]
+        self._save_model()
+
+        # Make a dataset backup
+        if self._gen_dataset_backup is None:
+            # Make a dataset backup
+            # FIXME This is a bad way - for large datasets very bad. It is a temporary solution
+            self._gen_dataset_backup = deepcopy(self.gen_dataset)
+
+    def _unlock(
+            self
+    ) -> None:
+        # Retract changes - reset dataset as before evasion attacks
+        # FIXME This is a bad way - for large datasets very bad. It is a temporary solution
+        self.gen_dataset = deepcopy(self._gen_dataset_backup)
 
     def do(
             self,
@@ -443,9 +460,12 @@ def _train_model(
             mode: Union[str, None],
             steps: Union[int, None]
     ) -> None:
+        apply_posisoning_ad = True if self.model_manager.modification.epochs == 0 else False
         self.model_manager.train_model(
             gen_dataset=self.gen_dataset, save_model_flag=False,
-            mode=mode, steps=steps, metrics=self.metrics, socket=self.socket)
+            mode=mode, steps=steps, metrics=self.metrics, socket=self.socket,
+            apply_posisoning_ad=apply_posisoning_ad)
+        self.socket.send(block='mt', msg={"info": "training-finished"})
 
     def _save_model(
             self
diff --git a/web_interface/main_aiohttp.py b/web_interface/main_aiohttp.py
@@ -259,7 +259,7 @@ def worker_process(
                         result = json_dumps(client.mcustomBlock.get_index())
                 elif do in ['train', 'reset', 'run', 'save']:
                     result = client.mtBlock.do(do, args)
-                elif do in ['run with attacks']:
+                elif do in ['run with attacks', 'save attack configs']:
                     result = client.atBlock.do(do, args)
                 else:
                     raise WebInterfaceError(f"Unknown do command: '{do}'")
diff --git a/web_interface/static/css/controls.css b/web_interface/static/css/controls.css
@@ -72,7 +72,7 @@
     border-bottom: 2px solid;
     padding: 4px;
     font-size: 14pt;
-    display: flex;
+    display: grid;
     align-items: center;
 }
 
diff --git a/web_interface/static/css/view.css b/web_interface/static/css/view.css
@@ -127,3 +127,23 @@ div.disabled * {
     -ms-user-select: none;
     user-select: none;
 }
+
+details.notAllowed {
+    cursor: not-allowed;
+}
+details.wait {
+    cursor: wait;
+}
+details.disabled {
+    opacity: 0.6;
+}
+details.disabled *:focus {
+    outline: 0;
+}
+details.disabled * {
+    pointer-events: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
diff --git a/web_interface/static/js/presentation/left_menu/model/menuAfterTrainView.js b/web_interface/static/js/presentation/left_menu/model/menuAfterTrainView.js
@@ -15,7 +15,8 @@ class MenuAfterTrainView extends MenuView {
         this.$methodSelects = Object.fromEntries(MenuAfterTrainView.names.map(x => [x, null]))
 
         // Buttons
-        this.$run = null
+        this.$run = null // Run with attacks
+        this.$save = null
         // this.$reset = null
     }
 
@@ -51,6 +52,16 @@ class MenuAfterTrainView extends MenuView {
         this.$acceptDiv.find('button').prop("disabled", false)
     }
 
+    async onsave() {
+        let configs = this._getConfigs()
+        this.$acceptDiv.find('button').prop("disabled", true)
+        this.$save.prop("disabled", true)
+        await controller.ajaxRequest('/model',
+            {do: "save attack configs", configs: JSON_stringify(configs)})
+        this.$save.prop("disabled", false)
+        this.$acceptDiv.find('button').prop("disabled", false)
+    }
+
     // Build buttons for model training process in model menu
     async addConfigMenu() {
         console.log('addConfigMenu')
@@ -126,5 +137,17 @@ class MenuAfterTrainView extends MenuView {
             this.onrun() // No await
         })
 
+        $cb = $("<div></div>").attr("class", "control-block")
+        this.$mainDiv.append($cb)
+        this.$save = $("<button></button>")
+            .attr("id", "model-button-save-after").text("Save")
+            .css("margin-right", "5px")
+            .attr("title", "Save the chosen attack configurations")
+        $cb.append(this.$save)
+
+        this.$save.click(async () => {
+            this.onsave() // No await
+        })
+
     }
 }
diff --git a/web_interface/static/js/presentation/left_menu/model/menuModelTrainerView.js b/web_interface/static/js/presentation/left_menu/model/menuModelTrainerView.js
diff --git a/web_interface/static/js/presentation/right_panel/model/panelModelStatView.js b/web_interface/static/js/presentation/right_panel/model/panelModelStatView.js

Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@`
`72`	`72`	`border-bottom: 2px solid;`
`73`	`73`	`padding: 4px;`
`74`	`74`	`font-size: 14pt;`
`75`		`- display: flex;`
	`75`	`+ display: grid;`
`76`	`76`	`align-items: center;`
`77`	`77`	`}`
`78`	`78`