BETTER-NMA 1.0.0__py3-none-any.whl

BETTER_NMA/query_image.py

@@ -0,0 +1,22 @@
+from .utilss.verbal_explanation import get_verbal_explanation
+from .utilss.photos_utils import preprocess_loaded_image
+from .utilss.models_utils import get_top_k_predictions
+
+def query_image(image, model, labels, dendrogram_object, top_k=5):
+    # predict image
+    try:
+        preprocessed_image, pil_image = preprocess_loaded_image(model, image)
+        predictions = get_top_k_predictions(
+            model, preprocessed_image, labels)
+        top_label = predictions[0][0]  # Top label
+        top_k_predictions = predictions[:top_k]
+
+        consistency = dendrogram_object.find_name_hierarchy(
+            dendrogram_object.Z_tree_format, top_label)
+        
+        explanation = get_verbal_explanation(consistency)
+        
+        return top_k_predictions, explanation
+    except Exception as e:
+        print("Error occurred while querying image:", e)
+        return None

BETTER_NMA/train_adversarial_detector.py

@@ -0,0 +1,21 @@
+from .utilss.classes.adversarial_detector import AdversarialDetector
+from .utilss.classes.adversarial_dataset import AdversarialDataset
+
+def _create_adversarial_dataset(Z_matrix, clean_images, adversarial_images, model, labels) -> dict:
+    adversarial_dataset = AdversarialDataset(model, clean_images, adversarial_images, Z_matrix, labels)
+    X_train, y_train, X_test, y_test = adversarial_dataset.create_logistic_regression_dataset()
+    result = {
+        "X_train": X_train,
+        "y_train": y_train,
+        "X_test": X_test,
+        "y_test": y_test
+    }   
+    return result
+
+def create_logistic_regression_detector(Z_matrix, model, clean_images, adversarial_images, labels):
+    adversarial_dataset = _create_adversarial_dataset(Z_matrix, clean_images, adversarial_images, model, labels)
+    adversarial_detector = AdversarialDetector(adversarial_dataset)
+
+    print("Adversarial detector trained successfully!")
+
+    return adversarial_detector

BETTER_NMA/utilss/classes/adversarial_dataset.py

@@ -0,0 +1,61 @@
+from sklearn.model_selection import train_test_split
+import numpy as np
+from .score_calculator import ScoreCalculator
+
+class AdversarialDataset:
+    def __init__(self, model, clear_images, adversarial_images, Z_full, labels):
+        self.model = model
+        self.clear_images = clear_images
+        self.adversarial_images = adversarial_images
+        self.score_calculator = ScoreCalculator(Z_full=Z_full, class_names=labels)
+
+    def create_logistic_regression_dataset(self):
+        scores = []
+        labels = []
+
+        print("getting preprocess function...")
+
+        try:
+            for image in self.clear_images[:50]:
+                # Add batch dimension for model prediction
+                image_batch = np.expand_dims(image, axis=0)
+                score = self.score_calculator.calculate_adversarial_score(self.model.predict(image_batch))
+                scores.append(score)
+                labels.append(0)
+        except Exception as e:
+            print(f"Error processing clean image: {e}")
+        
+        # Generate features for PGD attacks
+        print("Generating attack features...")
+        try:
+            for adv_image in self.adversarial_images[:50]:
+                # Add batch dimension for model prediction
+                adv_image_batch = np.expand_dims(adv_image, axis=0)
+                score = self.score_calculator.calculate_adversarial_score(self.model.predict(adv_image_batch))
+                scores.append(score)
+                labels.append(1)
+        except Exception as e:
+            print(f"Error processing PGD attack on image: {e}")
+
+        print("labels:", labels)
+        print("scores:", scores)
+        
+        # Convert to numpy arrays
+        X = np.array(scores)
+        y = np.array(labels)
+
+        # Reshape X to ensure it is 2D
+        if len(X.shape) == 1:
+            X = X.reshape(-1, 1)
+        
+        # Split into training and test sets
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.3, random_state=42
+        )
+        
+        print(f"Training data shape: {X_train.shape}")
+        print(f"Clean samples: {sum(y_train == 0)}, Adversarial samples: {sum(y_train == 1)}")
+        print(f"Test data shape: {X_test.shape}")
+        print(f"Clean samples: {sum(y_test == 0)}, Adversarial samples: {sum(y_test == 1)}")
+
+        return X_train, y_train, X_test, y_test

BETTER_NMA/utilss/classes/adversarial_detector.py

@@ -0,0 +1,63 @@
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import roc_curve
+import numpy as np
+
+class AdversarialDetector:
+    def __init__(self, dataset):
+        self.detector, self.threshold = self.train_adversarial_detector(dataset)
+
+        
+    def predict(self, X):
+        # Predict probabilities
+        if self.detector is None:
+            raise ValueError("Detector model is not trained or loaded.")
+        if X is None or len(X) == 0:
+            raise ValueError("Input data is empty or None.")
+        
+        y_pred_proba = self.detector.predict_proba(X)[:, 1]
+        # Apply the custom threshold
+        return (y_pred_proba >= self.threshold).astype(int)
+
+    def predict_proba(self, X):
+        if self.detector is None:
+            raise ValueError("Detector model is not trained or loaded.")
+        if X is None or len(X) == 0:
+            raise ValueError("Input data is empty or None.")
+        # Return predicted probabilities
+        return self.detector.predict_proba(X)
+
+    def train_adversarial_detector(self, dataset):
+        """
+        Train a logistic regression model to detect adversarial examples across different attack types.
+        
+        Parameters:
+        - model: The model being attacked
+        - Z_full: Hierarchical clustering data
+        - class_names: List of class names
+        - num_samples: Number of samples to use for training
+        
+        Returns:
+        - Trained detector model and evaluation metrics
+        """
+        
+        X_train, y_train = dataset['X_train'], dataset['y_train']
+
+        # Train logistic regression model
+        print("Training adversarial detector...")
+        detector = LogisticRegression(max_iter=1000, class_weight='balanced')
+        detector.fit(X_train, y_train)
+
+        X_test, y_test = dataset['X_test'], dataset['y_test']
+
+        # Predict probabilities for the test set
+        y_pred_proba = detector.predict_proba(X_test)[:, 1]
+
+        # Compute ROC curve and AUC
+        fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
+
+        # Find the optimal threshold (closest to top-left corner)
+        optimal_idx = np.argmax(tpr - fpr)
+        optimal_threshold = thresholds[optimal_idx]
+
+        return detector, optimal_threshold
+    

BETTER_NMA/utilss/classes/dendrogram.py

@@ -0,0 +1,131 @@
+from scipy.cluster.hierarchy import to_tree
+from ..wordnet_utils import process_hierarchy
+import json
+import os
+import pickle
+
+class Dendrogram:
+    def __init__(self, Z=None):
+        self.Z = Z
+        self.Z_tree_format = None
+        self.dendrogram_filename = None
+
+    def _build_tree_format(self, node, labels):
+        if node.is_leaf():
+            return {
+                "id": node.id,
+                "name": labels[node.id],
+                }
+        else:
+            return {
+                "id": node.id,
+                "name": f"cluster_{node.id}",
+                "children": [self._build_tree_format(node.get_left(), labels), self._build_tree_format(node.get_right(), labels)],
+                "value": node.dist
+            }
+
+    def build_tree_hierarchy(self, linkage_matrix, labels):
+        tree, nodes = to_tree(linkage_matrix, rd=True)
+        self.Z_tree_format = self._build_tree_format(tree, labels)
+        self.Z_tree_format = process_hierarchy(self.Z_tree_format)
+        return self.Z_tree_format  
+    
+    def filter_dendrogram_by_labels(self, full_data, target_labels):
+        def contains_target_label(node):
+            if 'children' not in node:
+                return node.get('name') in target_labels
+            for child in node.get('children', []):
+                if contains_target_label(child):
+                    return True
+            return False
+        def filter_tree(node):
+            if not contains_target_label(node):
+                return None
+            new_node = {
+                'id': node.get('id'),
+                'name': node.get('name')
+            }
+            if 'value' in node:
+                new_node['value'] = node.get('value')
+            if 'children' not in node:
+                return new_node
+            filtered_children = []
+            for child in node.get('children', []):
+                filtered_child = filter_tree(child)
+                if filtered_child:
+                    filtered_children.append(filtered_child)
+            if filtered_children:
+                new_node['children'] = filtered_children
+            return new_node
+        return filter_tree(full_data)
+
+    def merge_clusters(self, node):
+        if node is None:
+            return None
+        if "children" not in node:
+            return node
+        merged_children = []
+        for child in node["children"]:
+            merged_child = self.merge_clusters(child)
+            if merged_child:
+                merged_children.append(merged_child)
+        if all(c.get("value", 0) == 100 for c in merged_children):
+            node["children"] = [grandchild for child in merged_children for grandchild in child.get("children", [])]
+        else:
+            node["children"] = merged_children
+        if len(node["children"]) == 1:
+            return node["children"][0]
+        return node
+    
+    def get_sub_dendrogram_formatted(self, selected_labels):
+        filtered_tree = self.filter_dendrogram_by_labels(self.Z_tree_format, selected_labels)
+        if filtered_tree is None:
+            raise ValueError(f"No clusters found for the selected labels: {selected_labels}")
+        filtered_tree = self.merge_clusters(filtered_tree)
+        filtered_tree_json = json.dumps(filtered_tree, indent=2)
+        return filtered_tree_json
+    
+    def find_name_hierarchy(self, node, target_name):
+        if node.get('name') == target_name:
+            return [target_name]
+        if 'children' in node:
+            for child in node['children']:
+                result = self.find_name_hierarchy(child, target_name)
+                if result is not None:
+                    if node.get('name'):
+                        result.append(node['name'])
+                    return result
+        return None
+    
+    def rename_cluster(self, cluster_id, new_name):
+        print(f"Renaming cluster {cluster_id} to {new_name}")
+        def collect_names(node, names):
+            names.add(node.get('name'))
+            for child in node.get('children', []):
+                collect_names(child, names)
+        existing_names = set()
+        collect_names(self.Z_tree_format, existing_names)
+        unique_name = new_name
+        suffix = 1
+        while unique_name in existing_names:
+            unique_name = f"{new_name}_{suffix}"
+            suffix += 1
+            
+        def rename_node(node):
+            if node.get('id') == cluster_id:
+                node['name'] = unique_name
+            for child in node.get('children', []):
+                rename_node(child)
+        rename_node(self.Z_tree_format)
+        return self.Z_tree_format
+    
+    def get_node_name(self, node_id):
+        def find_name(node):
+            if node.get('id') == node_id:
+                return node.get('name')
+            for child in node.get('children', []):
+                result = find_name(child)
+                if result is not None:
+                    return result
+            return None
+        return find_name(self.Z_tree_format)

BETTER_NMA/utilss/classes/edges_dataframe.py

@@ -0,0 +1,53 @@
+import pandas as pd
+import os
+
+class EdgesDataframe:
+    def __init__(self, model_filename, edges_df_path):
+        """
+        Initialize EdgeDataframe handler.
+        
+        Args:
+            model_filename: Name/path of the model
+            edges_df_path: Path to the edges dataframe CSV file
+        """
+        self.model_filename = model_filename
+        self.edges_df_path = edges_df_path
+        self.dataframe = None
+        
+    def load_dataframe(self):
+        """Load the edges dataframe from CSV file."""
+        if not os.path.exists(self.edges_df_path):
+            raise FileNotFoundError(f"Edges dataframe not found at {self.edges_df_path}")
+        
+        self.dataframe = pd.read_csv(self.edges_df_path)
+        return self.dataframe
+    
+    def get_dataframe(self):
+        """Get the loaded dataframe."""
+        if self.dataframe is None:
+            raise ValueError("Dataframe not loaded. Call load_dataframe() first.")
+        return self.dataframe
+    
+    def save_dataframe(self, path=None):
+        """Save the dataframe to CSV."""
+        if self.dataframe is None:
+            raise ValueError("No dataframe to save.")
+        
+        save_path = path or self.edges_df_path
+        self.dataframe.to_csv(save_path, index=False)
+        return save_path
+    
+    def filter_by_labels(self, source_labels=None, target_labels=None):
+        """Filter dataframe by source and/or target labels."""
+        if self.dataframe is None:
+            raise ValueError("Dataframe not loaded.")
+        
+        filtered_df = self.dataframe.copy()
+        
+        if source_labels:
+            filtered_df = filtered_df[filtered_df['source'].isin(source_labels)]
+        
+        if target_labels:
+            filtered_df = filtered_df[filtered_df['target'].isin(target_labels)]
+        
+        return filtered_df

BETTER_NMA/utilss/classes/preprocessing/batch_predictor.py

@@ -0,0 +1,28 @@
+import numpy as np
+import tensorflow as tf
+
+
+class BatchPredictor:
+    def __init__(self, model, batch_size=32):
+        self.model = model
+        self.batch_size = batch_size
+        self.buffer_images = []  # To store images
+        self.buffer_labels = []  # To store corresponding labels
+        self.buffer_results = []  # To store batch results
+
+    def get_top_predictions(self, X, labels, top_k, graph_threshold):
+        batch_preds = self.model.predict(np.array(X))
+        batch_results = []
+        for pred in batch_preds:
+            top_indices = pred.argsort()[-top_k:][::-1]
+            valid_indices = [i for i in top_indices if i < len(labels)]
+
+            top_predictions = [
+                (i, labels[i], pred[i])
+                for i in valid_indices
+                if pred[i] >= graph_threshold
+            ]
+
+            batch_results.append(top_predictions)
+
+        return batch_results

BETTER_NMA/utilss/classes/preprocessing/graph_builder.py

@@ -0,0 +1,46 @@
+from ...enums.explanation_method import ExplanationMethod
+
+class GraphBuilder:
+    def __init__(self, graph_type, infinity):
+        self.graph_type = graph_type
+        self.infinity = infinity
+        
+    def create_edge_weight(self, pred_prob):
+        if self.graph_type == ExplanationMethod.DISSIMILARITY.value:
+            return 1 - pred_prob
+        elif self.graph_type == ExplanationMethod.COUNT.value:
+            return 1
+        return pred_prob
+    
+    def update_graph(self, graph, source_label, target_label, probability, image_id):
+        if source_label == target_label:
+            return None
+ 
+        weight = self.create_edge_weight(probability)
+
+        if graph.are_adjacent(source_label, target_label):
+            edge_id = graph.get_eid(source_label, target_label)
+            graph.es[edge_id]["weight"] += weight 
+        else:
+            graph.add_edge(source_label, target_label, weight=weight)
+        
+        edge_data = {
+            "image_id": image_id,
+            "source": source_label,
+            "target": target_label,
+            "target_probability": probability,
+        }
+        
+        return edge_data
+    
+    
+    def add_infinity_edges(self, graph, infinity_edges_labels, label, source_label):
+        if label == source_label:
+            return
+
+        if label not in infinity_edges_labels:
+            if graph.are_adjacent(source_label, label):
+                edge_id = graph.get_eid(source_label, label)
+                graph.es[edge_id]["weight"] += self.infinity
+            else:
+                graph.add_edge(source_label, label, weight=self.infinity) 

BETTER_NMA/utilss/classes/preprocessing/heap_processor.py

@@ -0,0 +1,30 @@
+import heapq
+import copy
+
+from ...enums.heap_types import HeapType
+from ...enums.explanation_method import ExplanationMethod
+
+class HeapProcessor:
+    def __init__(self,graph, graph_type, labels):
+        self.heap_type = self._get_heap_type(graph_type)
+        self.heap = []
+        self.nodes_multiplier = -1 if self.heap_type == "max" else 1
+        
+        self._process_edges(graph, labels)
+ 
+        
+    def _get_heap_type(self, graph_type):
+        return HeapType.MINIMUM.value if graph_type == ExplanationMethod.DISSIMILARITY.value else HeapType.MAXIMUM.value
+
+    def _process_edges(self, graph, labels):
+        for edge in graph.es:
+            source = graph.vs[edge.source]["name"]
+            target = graph.vs[edge.target]["name"]
+            weight = edge["weight"] if "weight" in edge.attributes() else 0
+            heapq.heappush(self.heap, (self.nodes_multiplier * weight, source, target))
+
+    def get_heap(self):
+        return self.heap
+
+    def get_heap_copy(self):
+        return copy.deepcopy(self.heap)

BETTER_NMA/utilss/classes/preprocessing/hierarchical_clustering_builder.py

@@ -0,0 +1,102 @@
+import numpy as np
+import json
+import os
+from .tree_node import TreeNode
+from ...enums.heap_types import HeapType
+
+class HierarchicalClusteringBuilder:
+    def __init__(self, heap_processor, labels):
+        self.nodes = {}
+        self.next_cluster_id = len(labels)
+        heap = heap_processor.get_heap()
+        self.max_weight = max((abs(weight) for weight,_, _ in heap), default=0)
+        self.forest = []
+        self._build(heap_processor, labels)
+        
+    def _initialize_nodes(self, labels):
+        for i, label in enumerate(labels):
+            self.nodes[label] = TreeNode(node_id=i, label=label)
+    
+    def _get_root(self, node):
+        while node.parent is not None:
+            node = node.parent
+        return node
+    
+    def _build(self, heap_processor, labels):
+        self._initialize_nodes(labels)
+        n = len(labels)
+        distances = np.full((n, n), np.inf)
+        np.fill_diagonal(distances, 0)
+        label_to_idx = {label: i for i, label in enumerate(labels)}
+        for weight, source, target in heap_processor.get_heap():
+            if heap_processor.heap_type == HeapType.MAXIMUM.value:
+                distance = self.max_weight - (-1*weight)
+            else:
+                distance = weight
+            src_idx = label_to_idx[source]
+            tgt_idx = label_to_idx[target]
+            distances[src_idx, tgt_idx] = distance
+            distances[tgt_idx, src_idx] = distance
+        max_dist = np.max(distances[~np.isinf(distances)])
+        distances[np.isinf(distances)] = max_dist * 2
+        active_clusters = {i: [i] for i in range(n)}
+        next_id = n
+        while len(active_clusters) > 1:
+            min_dist = float('inf')
+            closest_pair = None
+            for i in active_clusters:
+                for j in active_clusters:
+                    if i < j:
+                        dist_sum = 0
+                        count = 0
+                        for idx1 in active_clusters[i]:
+                            for idx2 in active_clusters[j]:
+                                dist_sum += distances[idx1, idx2]
+                                count += 1
+                        avg_dist = dist_sum / count
+                        if avg_dist < min_dist:
+                            min_dist = avg_dist
+                            closest_pair = (i, j)
+            i, j = closest_pair
+            if len(active_clusters[i]) == 1:
+                node_i = self.nodes[labels[active_clusters[i][0]]]
+            else:
+                node_i = self.nodes[f"cluster_{i}"]
+            if len(active_clusters[j]) == 1:
+                node_j = self.nodes[labels[active_clusters[j][0]]]
+            else:
+                node_j = self.nodes[f"cluster_{j}"]
+            cluster_name = f"cluster_{next_id}"
+            new_node = TreeNode(
+                node_id=next_id,
+                label=cluster_name,
+                children=[node_i, node_j],
+                weight=min_dist
+            )
+            self.nodes[cluster_name] = new_node
+            node_i.parent = new_node
+            node_j.parent = new_node
+            merged_cluster = active_clusters[i] + active_clusters[j]
+            active_clusters[next_id] = merged_cluster
+            del active_clusters[i]
+            del active_clusters[j]
+            next_id += 1
+        final_id = list(active_clusters.keys())[0]
+        if final_id < n:
+            self.final_tree = self.nodes[labels[final_id]]
+        else:
+            self.final_tree = self.nodes[f"cluster_{final_id}"]
+        self.forest = [self.final_tree]
+        print(f"Built a forest with {len(self.forest)} tree{'s' if len(self.forest) > 1 else ''}")
+    
+
+    def get_forest(self):
+        return self.forest
+    
+    def get_tree(self, index=0):
+        if 0 <= index < len(self.forest):
+            return self.forest[index]
+        return None
+        
+    def forest_size(self):
+        return len(self.forest)

BETTER_NMA/utilss/classes/preprocessing/tree_node.py

@@ -0,0 +1,71 @@
+from nltk.tree import Tree
+
+class TreeNode(Tree):
+    def __init__(self, node_id, label=None, children=None, weight=0, parent=None):
+        self.node_name = label if label else f"cluster {node_id}"
+        super().__init__(self.node_name, children if children else [])
+        self.node_id = node_id
+        self.weight = weight
+        self.parent = parent
+        if children:
+            for child in children:
+                if isinstance(child, TreeNode):
+                    child.parent = self
+
+    def __hash__(self):
+        return hash(self.node_id)
+
+    def __eq__(self, other):
+        if not isinstance(other, TreeNode):
+            return False
+        return self.node_id == other.node_id
+
+    def add_child(self, child):
+        if isinstance(child, TreeNode):
+            child.parent = self
+        self.append(child)
+        return self
+
+    @classmethod
+    def create_parent(cls, node_id, children, label=None, weight=0):
+        parent = cls(node_id, label, weight=weight)
+        for child in children:
+            parent.add_child(child)
+        return parent
+
+    def get_root(self):
+        current = self
+        while current.parent is not None:
+            current = current.parent
+        return current
+
+    def get_path_to_root(self):
+        path = []
+        current = self
+        while current is not None:
+            path.append(current)
+            current = current.parent
+        return path
+
+    def find_lca(self, other_node):
+        if not isinstance(other_node, TreeNode):
+            raise TypeError("Expected TreeNode node")
+        path1 = []
+        current = self
+        while current is not None:
+            path1.append(current)
+            current = current.parent
+        path2 = []
+        current = other_node
+        while current is not None:
+            path2.append(current)
+            current = current.parent
+        path1.reverse()
+        path2.reverse()
+        lca = None
+        for i in range(min(len(path1), len(path2))):
+            if path1[i] is path2[i]:
+                lca = path1[i]
+            else:
+                break
+        return lca