BETTER-NMA 1.0.0__py3-none-any.whl

BETTER_NMA/utilss/classes/preprocessing/z_builder.py

@@ -0,0 +1,93 @@
+import numpy as np
+
+class ZBuilder:
+    def create_z_matrix_from_tree(self, clustering_builder, labels):
+        unique_labels = []
+        seen_labels = set()
+
+        for label in labels:
+            if label not in seen_labels:
+                unique_labels.append(label)
+                seen_labels.add(label)
+
+        print(f"Total labels: {len(labels)}, Unique labels: {len(unique_labels)}")
+        label_to_idx = {label: i for i, label in enumerate(unique_labels)}
+
+        n = len(unique_labels)
+        z_matrix = np.zeros((n - 1, 4), dtype=np.float64)
+        if not clustering_builder.forest:
+            print("ERROR: No tree found in the forest!")
+            return z_matrix, unique_labels
+
+        root = clustering_builder.forest[0]
+        processed = {}
+        next_z_idx = n
+        row_idx = 0
+        
+        def process_node(node):
+            nonlocal row_idx, next_z_idx
+            if node.node_id in processed:
+                return processed[node.node_id]
+            
+            if len(node) == 0:
+                if hasattr(node, "node_name") and node.node_name in label_to_idx:
+                    idx = label_to_idx[node.node_name]
+                    processed[node.node_id] = idx
+                    return idx
+                else:
+                    return None
+            left_idx = None
+            right_idx = None
+
+            if len(node) >= 1:
+                left_idx = process_node(node[0])
+            if len(node) >= 2:
+                right_idx = process_node(node[1])
+            if left_idx is None or right_idx is None:
+                return None
+            if left_idx > right_idx:
+                left_idx, right_idx = right_idx, left_idx
+            left_count = 1 if left_idx < n else z_matrix[left_idx - n][3]
+            right_count = 1 if right_idx < n else z_matrix[right_idx - n][3]
+            
+            if row_idx < n - 1:
+                z_matrix[row_idx] = [
+                    left_idx,
+                    right_idx,
+                    node.weight,
+                    left_count + right_count,
+                ]
+                this_idx = next_z_idx
+                processed[node.node_id] = this_idx
+                next_z_idx += 1
+                row_idx += 1
+                return this_idx
+
+            return None
+        
+        process_node(root)
+        if row_idx < n - 1:
+            print(f"WARNING: Only filled {row_idx} of {n-1} rows in Z matrix!")
+            # Trim the matrix to the actual number of rows we filled
+            z_matrix = z_matrix[:row_idx]
+            
+        for i in range(z_matrix.shape[0]):
+            left_idx = int(z_matrix[i, 0])
+            right_idx = int(z_matrix[i, 1])
+            left_size = 1 if left_idx < n else z_matrix[left_idx - n, 3]
+            right_size = 1 if right_idx < n else z_matrix[right_idx - n, 3]
+            expected_size = left_size + right_size
+            if z_matrix[i, 3] != expected_size:
+                print(
+                    f"Fixing cluster size at row {i}: {z_matrix[i, 3]} → {expected_size}"
+                )
+                z_matrix[i, 3] = expected_size
+            max_size = z_matrix.shape[0] + 1
+            
+            if z_matrix[i, 3] > max_size:
+                print(
+                    f"Capping excessive cluster size at row {i}: {z_matrix[i, 3]} → {max_size}"
+                )
+                z_matrix[i, 3] = max_size
+
+        return np.asarray(z_matrix, dtype=np.float64)

BETTER_NMA/utilss/classes/score_calculator.py

@@ -0,0 +1,165 @@
+import numpy as np
+import pickle
+
+class ScoreCalculator:
+    def __init__(self, Z_full, class_names):
+        # Check if Z_full is a file path (string) or numpy array
+        if isinstance(Z_full, str):
+            try:
+                with open(Z_full, 'rb') as file:
+                    self.Z_full = pickle.load(file)
+            except (FileNotFoundError, pickle.UnpicklingError) as e:
+                print(f"Error loading Z file: {e}")
+                self.Z_full = None
+        elif isinstance(Z_full, np.ndarray):
+            # Z_full is already a numpy array
+            self.Z_full = Z_full
+        else:
+            print(f"Warning: Z_full type {type(Z_full)} not supported. Expected string (file path) or numpy array.")
+            self.Z_full = Z_full
+        
+        self.class_names = class_names
+
+
+    def count_ancestors_to_lca(self, label1, label2):
+        """
+        Count the number of ancestors for each node until they reach their lowest common ancestor.
+        
+        Parameters:
+        - Z_full: The full Z matrix from hierarchical clustering
+        - class_names: List of all class names
+        - label1, label2: Class labels to compare
+        
+        Returns:
+        - total_count: Total number of ancestors traversed to reach LCA
+        """
+        # Convert labels to indices if needed
+        if isinstance(label1, str):
+            idx1 = self.class_names.index(label1)
+        else:
+            idx1 = label1
+            
+        if isinstance(label2, str):
+            idx2 = self.class_names.index(label2)
+        else:
+            idx2 = label2
+        
+        # Build the hierarchical structure
+        n_samples = len(self.class_names)
+        n_nodes = 2 * n_samples - 1
+        
+        # Initialize parent mapping
+        parent = np.zeros(n_nodes, dtype=np.int64) - 1  # -1 means no parent
+        
+        # Fill in the structure from Z
+        for i, (left, right, height, _) in enumerate(self.Z_full):
+            left = int(left)
+            right = int(right)
+            node_id = n_samples + i
+            
+            parent[left] = node_id
+            parent[right] = node_id
+        
+        # Trace path from node1 to root
+        path1 = []
+        current = idx1
+        while parent[current] != -1:
+            path1.append(parent[current])
+            current = parent[current]
+        
+        # Trace path from node2 to LCA
+        path2 = []
+        current = idx2
+        lca = None
+        
+        while parent[current] != -1:
+            current_parent = parent[current]
+            path2.append(current_parent)
+            
+            if current_parent in path1:
+                # Found the LCA
+                lca = current_parent
+                break
+            
+            current = current_parent
+        
+        # If no LCA found (shouldn't happen in a proper hierarchy), return max value
+        if lca is None:
+            return n_nodes
+        
+        # Count steps from node1 to LCA
+        steps1 = path1.index(lca) + 1
+        
+        # Count steps from node2 to LCA
+        steps2 = path2.index(lca) + 1
+        
+        # Total number of ancestors traversed
+        total_count = steps1 + steps2
+        
+        return total_count, lca
+    
+    def calculate_adversarial_score(self, predictions, top_k=5):
+        """
+        Calculate adversarial attack score based on statistical anomaly detection.
+        Works regardless of whether attacks increase or decrease semantic distance.
+        
+        Parameters:
+        - Z_full: The full Z matrix from hierarchical clustering
+        - class_names: List of all class names
+        - predictions: Model output predictions (logits or probabilities)
+        - top_k: Number of top predictions to consider
+        
+        Returns:
+        - Dictionary with score and detailed information
+        """
+        # Get top-k predictions
+        if len(predictions.shape) > 1:
+            predictions = predictions[0]  # For batch predictions, take the first item
+            
+            
+        top_indices = np.argsort(predictions)[-top_k:][::-1]
+        top_probs = [predictions[i] for i in top_indices]
+        top_labels = [self.class_names[i] for i in top_indices]
+        
+        # Calculate ancestors to LCA for all pairs
+        pairwise_distances = []
+        distance_prob_products = []
+        all_pairs = []
+        
+        for i in range(len(top_indices)):
+            for j in range(i+1, len(top_indices)):
+                idx1, idx2 = top_indices[i], top_indices[j]
+                label1, label2 = top_labels[i], top_labels[j]
+                prob1, prob2 = top_probs[i], top_probs[j]
+                
+                # Calculate semantic distance
+                rank_count, _ = self.count_ancestors_to_lca(idx1, idx2)
+                print(f"Rank Count for {label1} and {label2}: {rank_count}")
+                
+                # Calculate product of probabilities and distance
+                prob_product = prob1 * prob2
+                rank_prob = rank_count * prob_product
+                
+                pair_info = {
+                    'label1': label1,
+                    'label2': label2,
+                    'probability1': float(prob1),
+                    'probability2': float(prob2),
+                    'ancestor_distance': rank_count,
+                    'prob_product': prob_product,
+                    'weighted_distance': rank_prob
+                }
+                
+                pairwise_distances.append(rank_count)
+                distance_prob_products.append(rank_prob)
+                all_pairs.append(pair_info)
+        
+        # Calculate statistics
+        if pairwise_distances:
+            sum_distance = sum(pairwise_distances)
+            score = sum_distance
+        else:
+            score = 0
+        
+        return score
+        

BETTER_NMA/utilss/classes/whitebox_testing.py

@@ -0,0 +1,35 @@
+import pandas as pd
+
+class WhiteBoxTesting:
+    def __init__(self, model_name):
+        self.model_name = model_name
+        self.problematic_img_ids = None
+        self.problematic_img_preds = None
+        
+        
+    def find_problematic_images(self, source_labels, target_labels, edges_df, explanation_method=None):
+        filtered_edges_df = edges_df[
+            (edges_df['source'].isin(source_labels)) & 
+            (edges_df['target'].isin(target_labels))
+        ]
+
+        filtered_edges_df_switched = edges_df[
+            (edges_df['source'].isin(target_labels)) & 
+            (edges_df['target'].isin(source_labels))
+        ]
+        print(filtered_edges_df_switched.head())
+        
+        combined_filtered_edges_df = pd.concat([filtered_edges_df, filtered_edges_df_switched])
+        print("Combined filtered edges dataset:")
+        print(combined_filtered_edges_df)
+        
+        unique_ids_list = combined_filtered_edges_df['image_id'].unique().tolist()
+        
+        matched_dict = {
+            image_id: list(zip(group['source'], group['target'], group['target_probability']))
+            for image_id, group in edges_df[edges_df['image_id'].isin(unique_ids_list)].groupby('image_id')
+        }
+        print("Matched dictionary:")
+        print(matched_dict)
+        
+        return matched_dict

BETTER_NMA/utilss/enums/explanation_method.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class ExplanationMethod(Enum):
+    SIMILARITY = "similarity"
+    DISSIMILARITY = "dissimilarity"
+    COUNT = "count_based"

BETTER_NMA/utilss/enums/heap_types.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class HeapType(Enum):
+    MINIMUM = "min"
+    MAXIMUM = "max"

BETTER_NMA/utilss/models_utils.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+def get_top_k_predictions(model, image, class_names, top_k=5):
+    # Get predictions from the model
+    predictions = model.predict(image)
+
+    # Flatten the predictions array if it's 2D (e.g., shape (1, num_classes))
+    if len(predictions.shape) == 2:
+        predictions = predictions[0]  # Extract the first (and only) batch
+
+    # Get the indices of the top-k predictions
+    top_indices = np.argsort(predictions)[-top_k:][::-1]
+
+    # Get the top-k probabilities and corresponding labels
+    top_probs = predictions[top_indices]
+    top_labels = [class_names[i] for i in top_indices]
+
+    return list(zip(top_labels, top_probs))

BETTER_NMA/utilss/photos_uitls.py

@@ -0,0 +1,72 @@
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.applications.resnet50 import preprocess_input as resnet50_preprocess
+from tensorflow.keras.applications.vgg16 import preprocess_input as vgg16_preprocess
+from tensorflow.keras.applications.inception_v3 import preprocess_input as inception_v3_preprocess
+from tensorflow.keras.applications.mobilenet import preprocess_input as mobilenet_preprocess
+from tensorflow.keras.applications.efficientnet import preprocess_input as efficientnet_preprocess
+from tensorflow.keras.applications.xception import preprocess_input as xception_preprocess
+from PIL import Image
+import io
+
+def get_preprocess_function(model):
+    print("Determining preprocessing function based on model configuration...")
+    preprocess_map = {
+        "resnet50": resnet50_preprocess,
+        "vgg16": vgg16_preprocess,
+        "inception_v3": inception_v3_preprocess,
+        "mobilenet": mobilenet_preprocess,
+        "efficientnet": efficientnet_preprocess,
+        "xception": xception_preprocess,
+    }
+
+    model_config = model.get_config()
+    if "name" in model_config:
+        model_name = model_config["name"].lower()
+        print(f"Model name: {model_name}")
+        for key in preprocess_map.keys():
+            if key in model_name:
+                print(f"Detected model type: {key}")
+                return preprocess_map[key]
+
+    for layer in model.layers:
+        layer_name = layer.name.lower()
+        print(f"Checking layer: {layer_name}")
+        for model_name in preprocess_map.keys():
+            if model_name in layer_name:
+                print(f"Detected model type: {model_name}")
+                return preprocess_map[model_name]
+
+    print("No supported model type found in the configuration. Falling back to generic normalization.")
+    return lambda x: x / 255.0  # Generic normalization to [0, 1]
+
+
+_cached_preprocess_function = {}
+
+def get_cached_preprocess_function(model):
+    """
+    Get the cached preprocessing function for the given model.
+    If not cached, fetch it and store it in the cache.
+    """
+    global _cached_preprocess_function
+    model_id = id(model)  # Use the model's unique ID as the cache key
+    if model_id not in _cached_preprocess_function:
+        _cached_preprocess_function[model_id] = get_preprocess_function(model)
+    return _cached_preprocess_function[model_id]
+
+def preprocess_loaded_image(model, image):
+    expected_shape = model.input_shape
+    input_height, input_width = expected_shape[1], expected_shape[2]
+    pil_image = Image.open(io.BytesIO(image)).convert("RGB")
+    pil_image = pil_image.resize((input_width, input_height))
+    preprocess_input = get_cached_preprocess_function(model)
+    image_array = preprocess_input(np.array(pil_image))
+    image_preprocessed = np.expand_dims(image_array, axis=0)
+    return image_preprocessed
+
+def preprocess_image(model, image):
+    preprocess_input = get_cached_preprocess_function(model)
+    image_array = preprocess_input(np.array(image))
+    image_preprocessed = np.expand_dims(image_array, axis=0)
+    return image_preprocessed

BETTER_NMA/utilss/photos_utils.py

@@ -0,0 +1,104 @@
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.applications.resnet50 import preprocess_input as resnet50_preprocess
+from tensorflow.keras.applications.vgg16 import preprocess_input as vgg16_preprocess
+from tensorflow.keras.applications.inception_v3 import preprocess_input as inception_v3_preprocess
+from tensorflow.keras.applications.mobilenet import preprocess_input as mobilenet_preprocess
+from tensorflow.keras.applications.efficientnet import preprocess_input as efficientnet_preprocess
+from tensorflow.keras.applications.xception import preprocess_input as xception_preprocess
+from PIL import Image
+import io
+import base64
+
+def get_preprocess_function(model):
+    print("Determining preprocessing function based on model configuration...")
+    preprocess_map = {
+        "resnet50": resnet50_preprocess,
+        "vgg16": vgg16_preprocess,
+        "inception_v3": inception_v3_preprocess,
+        "mobilenet": mobilenet_preprocess,
+        "efficientnet": efficientnet_preprocess,
+        "xception": xception_preprocess,
+    }
+
+    model_config = model.get_config()
+    if "name" in model_config:
+        model_name = model_config["name"].lower()
+        print(f"Model name: {model_name}")
+        for key in preprocess_map.keys():
+            if key in model_name:
+                print(f"Detected model type: {key}")
+                return preprocess_map[key]
+
+    for layer in model.layers:
+        layer_name = layer.name.lower()
+        print(f"Checking layer: {layer_name}")
+        for model_name in preprocess_map.keys():
+            if model_name in layer_name:
+                print(f"Detected model type: {model_name}")
+                return preprocess_map[model_name]
+
+    print("No supported model type found in the configuration. Falling back to generic normalization.")
+    return lambda x: x / 255.0  # Generic normalization to [0, 1]
+
+
+_cached_preprocess_function = {}
+
+def get_cached_preprocess_function(model):
+    global _cached_preprocess_function
+    model_id = id(model)
+    if model_id not in _cached_preprocess_function:
+        _cached_preprocess_function[model_id] = get_preprocess_function(model)
+    return _cached_preprocess_function[model_id]
+
+def preprocess_loaded_image(model, image):
+    expected_shape = model.input_shape
+    input_height, input_width = expected_shape[1], expected_shape[2]
+
+     # Handle different input types
+    if isinstance(image, bytes):
+        # If image is bytes, convert to PIL Image
+        pil_image = Image.open(io.BytesIO(image)).convert("RGB")
+    elif isinstance(image, Image.Image):
+        # If image is already a PIL Image, just convert to RGB
+        pil_image = image.convert("RGB")
+    elif isinstance(image, np.ndarray):
+        # If image is numpy array, convert to PIL Image
+        if image.dtype == np.uint8:
+            pil_image = Image.fromarray(image)
+        else:
+            # Normalize to 0-255 if not uint8
+            image_normalized = ((image - image.min()) / (image.max() - image.min()) * 255).astype(np.uint8)
+            pil_image = Image.fromarray(image_normalized)
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+    
+    # pil_image = Image.open(io.BytesIO(image)).convert("RGB")
+    pil_image = pil_image.resize((input_width, input_height))
+    preprocess_input = get_cached_preprocess_function(model)
+    image_array = preprocess_input(np.array(pil_image))
+    image_preprocessed = np.expand_dims(image_array, axis=0)
+    return image_preprocessed, pil_image
+
+def preprocess_image(model, image):
+    preprocess_input = get_cached_preprocess_function(model)
+    image_array = preprocess_input(np.array(image))
+    image_preprocessed = np.expand_dims(image_array, axis=0)
+    return image_preprocessed
+
+def encode_image_to_base64(image):
+    if isinstance(image, np.ndarray):
+        if image.dtype != np.uint8:
+            if image.max() <= 1.0:
+                image = (image * 255).astype(np.uint8)
+            else:
+                image = image.astype(np.uint8)
+        
+        pil_image = Image.fromarray(image)
+        buffered = io.BytesIO()
+        pil_image.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        return img_str
+    else:
+        raise ValueError("Input must be a numpy array")

BETTER_NMA/utilss/verbal_explanation.py

@@ -0,0 +1,15 @@
+import re
+
+def get_verbal_explanation(explanation):
+    
+    result = []
+    for i, word in enumerate(explanation):
+        sanitized_word = re.sub(r'[0-9_]', '', word)
+        if i == 0:
+            result.append(f"**{sanitized_word}**")  # You can use bold markdown or just the word
+        else:
+            prev_sanitized = re.sub(r'[0-9_]', '', explanation[i - 1])
+            if sanitized_word == prev_sanitized:
+                continue
+            result.append(f" is a part of **{sanitized_word}**")
+    return ''.join(result)