BETTER-NMA 1.0.1__py3-none-any.whl → 1.0.5__py3-none-any.whl

BETTER_NMA/explaination_score.py

@@ -0,0 +1,52 @@
+from .utilss.classes.score_calculator import ScoreCalculator
+from itertools import combinations
+
+def get_explaination_score(dendrogram, class_names, normalize=True):
+    """
+    Get the score of the entire dendrogram based on pairwise LCA ancestor counts.
+
+    Parameters:
+    - dendrogram: The hierarchical clustering dendrogram
+    - class_names: List of class names corresponding to model outputs
+
+    Returns:
+    - score: The explanation score of the dendrogram
+    """
+    score_calculator = ScoreCalculator(dendrogram.Z, class_names)
+    
+    total_count = 0
+    num_classes = len(class_names)
+
+    # Get all combinations of 2 labels from class_names
+    for label1, label2 in combinations(class_names, 2):
+        try:
+            idx1 = class_names.index(label1)
+            idx2 = class_names.index(label2)
+            count, _ = score_calculator.count_ancestors_to_lca(idx1, idx2)
+            total_count += count
+        except ValueError as e:
+            print(f"Error processing pair ({label1}, {label2}): {e}")
+            continue
+
+    total_combinations = len(list(combinations(class_names, 2)))
+    print(f"Total combinations processed: {total_combinations}")
+    print(f"Total ancestor count sum: {total_count}")
+    
+    if normalize:
+        # Maximum ancestors = height of dendrogram tree
+        max_ancestors_per_pair = num_classes - 1  # Maximum tree height
+        theoretical_max = total_combinations * max_ancestors_per_pair
+        
+        if theoretical_max == 0:
+            normalized_score = 0
+        else:
+            # Invert the score so higher ancestor counts = lower explanation quality
+            # and normalize to 0-100%
+            normalized_score = max(0, (1 - (total_count / theoretical_max)) * 100)
+        
+        print(f"Theoretical maximum: {theoretical_max}")
+        print(f"Normalized score: {normalized_score:.2f}%")
+        
+        return normalized_score
+    else:
+        return total_count

BETTER_NMA/main.py

@@ -8,8 +8,11 @@ from .detect_attack import detect_adversarial_image
 from .query_image import query_image
 from .utilss.verbal_explanation import get_verbal_explanation
 from .white_box_testing import analyze_white_box_results, get_white_box_analysis
+from .explaination_score import get_explaination_score
 from .adversarial_score import get_adversarial_score
 from .find_lca import get_lca
+from .utilss.wordnet_utils import synset_to_readable
+import json
 
 class NMA:
     def __init__(self, x_train, y_train, labels, model, explanation_method, top_k=4, min_confidence=0.8, infinity=None, threshold=1e-6, save_connections=False, batch_size=32):
@@ -36,13 +39,12 @@ class NMA:
         self.model = model
         self.explanation_method = explanation_method
         self.top_k = top_k
-        self.labels = labels
+        self.labels = [synset_to_readable(label) for label in labels]
         self.min_confidence = min_confidence
         self.infinity = infinity
         self.threshold = threshold
         self.save_connections = save_connections
         self.batch_size = batch_size
-        self.labels = labels
         self.detector = None
 
         self.dendrogram_object, self.edges_df = preprocessing(x_train, y_train, labels, model, explanation_method, top_k, min_confidence, infinity, threshold, save_connections, batch_size)
@@ -81,6 +83,25 @@ class NMA:
         """
         plot_sub_dendrogram(self.dendrogram_object.Z, self.labels, sub_labels, title=title, figsize=figsize)
 
+
+    def get_tree_as_dict(self, sub_labels=None):
+        """
+        Returns the dendrogram hierarchy as a mutable Python dictionary.
+
+        Inputs:
+        - sub_labels (optional): List of labels to include in the subset.
+
+        Outputs: Dictionary representation of the dendrogram tree.
+        """
+        if self.dendrogram_object is None:
+            raise ValueError("Dendrogram not available.")
+        
+        if sub_labels is None:
+            sub_labels = self.labels
+            
+        json_str = self.dendrogram_object.get_sub_dendrogram_formatted(sub_labels)
+        return json.loads(json_str)
+    
     ## white box testing functions: ##
 
     def white_box_testing(self, source_labels, target_labels, analyze_results=False, x_train=None, encode_images=True):
@@ -101,7 +122,7 @@ class NMA:
         if self.edges_df is None:
             raise ValueError("White box testing requires edges_df. Initialize NMA with save_connections=True")
 
-        whitebox = WhiteBoxTesting(self.model.name if hasattr(self.model, 'name') else "model")
+        whitebox = WhiteBoxTesting(self.model.name if hasattr(self.model, 'name') else "model", verbose=False)
         problematic_imgs_dict = whitebox.find_problematic_images(
             source_labels, target_labels, self.edges_df, self.explanation_method)
 
@@ -212,6 +233,10 @@ class NMA:
         score = get_adversarial_score(image, self.model, self.dendrogram_object.Z, self.labels, top_k=top_k)
         return score
 
+    def explanation_score(self, normalize=True):
+        return get_explaination_score(self.dendrogram_object, self.labels, normalize=normalize)
+
+
     ## query and explanation functions: ##
 
     def query_image(self, image, top_k=5):

BETTER_NMA/nma_creator.py

@@ -8,11 +8,13 @@ from .utilss.classes.preprocessing.graph_builder import GraphBuilder
 from .utilss.classes.preprocessing.hierarchical_clustering_builder import HierarchicalClusteringBuilder
 from .utilss.classes.preprocessing.z_builder import ZBuilder
 from .utilss.classes.dendrogram import Dendrogram
+from .utilss.wordnet_utils import synset_to_readable
 
 def preprocessing(x_train, y_train, labels, model, explanation_method, top_k, min_confidence, infinity, threshold, save_connections, batch_size=32):
     try:
         X = x_train
-        y = y_train
+        y = [synset_to_readable(l) for l in y_train]
+        labels = [synset_to_readable(l) for l in labels]
         
         graph = Graph(directed=False)
         graph.add_vertices(labels)

BETTER_NMA/plot.py

@@ -101,31 +101,14 @@ def plot(nma_instance, sub_labels, title, figsize, **kwargs):
         raise ValueError("No linkage matrix (z) found in NMA instance")
 
     if sub_labels is None:
-        sub_labels = nma_instance.labels
+        print("No sub_labels provided.")
+        return
         
-    filtered_dendrogram_json = nma_instance.dendrogram_object.get_sub_dendrogram_formatted(
-        sub_labels)
-    print("Filtered dendrogram structure:")
-    print(filtered_dendrogram_json)
+    _ = nma_instance.dendrogram_object.get_sub_dendrogram_formatted(sub_labels)
+    # filtered_dendrogram_json = nma_instance.dendrogram_object.get_sub_dendrogram_formatted(
+    #     sub_labels)
 
     if hasattr(nma_instance, 'labels'):
         plot_sub_dendrogram(nma_instance.dendrogram_object.Z,
                             nma_instance.labels, sub_labels, title, figsize)
 
-    print(nma_instance.dendrogram_object.Z)
-
-    # plt.figure(figsize=(20, 15))
-    # sch.dendrogram(
-    #     nma_instance.z,
-    #     leaf_rotation=0,
-    #     leaf_font_size=10,
-    #     orientation='right',
-    #     color_threshold=85,
-    #     **kwargs
-    # )
-    # plt.title('NMA Hierarchical Clustering Dendrogram')
-    # plt.xlabel('Elements')
-    # plt.ylabel('Distance')
-    # plt.tight_layout()
-    # plt.show()
-

BETTER_NMA/utilss/classes/adversarial_dataset.py

@@ -13,32 +13,27 @@ class AdversarialDataset:
         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))
+                score = self.score_calculator.calculate_adversarial_score(self.model.predict(image_batch, verbose=0))
                 scores.append(score)
                 labels.append(0)
         except Exception as e:
-            print(f"Error processing clean image: {e}")
+            print(f"Error processing clean images: {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))
+                score = self.score_calculator.calculate_adversarial_score(self.model.predict(adv_image_batch, verbose=0))
                 scores.append(score)
                 labels.append(1)
         except Exception as e:
-            print(f"Error processing PGD attack on image: {e}")
+            print(f"Error processing attacked images: {e}")
 
-        print("labels:", labels)
-        print("scores:", scores)
         
         # Convert to numpy arrays
         X = np.array(scores)

BETTER_NMA/utilss/classes/preprocessing/batch_predictor.py

@@ -1,5 +1,6 @@
 import numpy as np
 import tensorflow as tf
+from ...wordnet_utils import synset_to_readable
 
 
 class BatchPredictor:
@@ -11,14 +12,15 @@ class BatchPredictor:
         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_preds = self.model.predict(np.array(X), verbose=0)
         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])
+                # (i, labels[i], pred[i])
+                (i, synset_to_readable(labels[i]), pred[i]) 
                 for i in valid_indices
                 if pred[i] >= graph_threshold
             ]

BETTER_NMA/utilss/classes/score_calculator.py

@@ -134,7 +134,6 @@ class ScoreCalculator:
                 
                 # 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

BETTER_NMA/utilss/classes/whitebox_testing.py

@@ -1,10 +1,11 @@
 import pandas as pd
 
 class WhiteBoxTesting:
-    def __init__(self, model_name):
+    def __init__(self, model_name, verbose=False):
         self.model_name = model_name
         self.problematic_img_ids = None
         self.problematic_img_preds = None
+        self.verbose = verbose
         
         
     def find_problematic_images(self, source_labels, target_labels, edges_df, explanation_method=None):
@@ -17,11 +18,15 @@ class WhiteBoxTesting:
             (edges_df['source'].isin(target_labels)) & 
             (edges_df['target'].isin(source_labels))
         ]
-        print(filtered_edges_df_switched.head())
+        
+        if self.verbose:
+            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)
+        
+        if self.verbose:
+            print("Combined filtered edges dataset:")
+            print(combined_filtered_edges_df)
         
         unique_ids_list = combined_filtered_edges_df['image_id'].unique().tolist()
         
@@ -29,7 +34,9 @@ class WhiteBoxTesting:
             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)
+        
+        if self.verbose:
+            print("Matched dictionary:")
+            print(matched_dict)
         
         return matched_dict

BETTER_NMA/utilss/photos_uitls.py

@@ -24,10 +24,10 @@ def get_preprocess_function(model):
     model_config = model.get_config()
     if "name" in model_config:
         model_name = model_config["name"].lower()
-        print(f"Model name: {model_name}")
+        # print(f"Model name: {model_name}")
         for key in preprocess_map.keys():
             if key in model_name:
-                print(f"Detected model type: {key}")
+                # print(f"Detected model type: {key}")
                 return preprocess_map[key]
 
     for layer in model.layers:
@@ -35,7 +35,7 @@ def get_preprocess_function(model):
         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}")
+                # 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.")

BETTER_NMA/utilss/photos_utils.py

@@ -25,15 +25,15 @@ def get_preprocess_function(model):
     model_config = model.get_config()
     if "name" in model_config:
         model_name = model_config["name"].lower()
-        print(f"Model name: {model_name}")
+        # print(f"Model name: {model_name}")
         for key in preprocess_map.keys():
             if key in model_name:
-                print(f"Detected model type: {key}")
+                # 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}")
+        # 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}")

BETTER_NMA/utilss/wordnet_utils.py

@@ -12,9 +12,32 @@ def folder_name_to_number(folder_name):
         folder_number = 'n{:08d}'.format(offset)
         return folder_number
     
+def synset_to_readable(label):
+    # Check if label is in synset format
+    if isinstance(label, str) and label.startswith('n') and label[1:].isdigit():
+        special_cases = {
+        "n02012849": "crane bird",      # Bird
+        "n03126707": "crane machine",   # Vehicle
+        "n03710637": "maillot",         # Swimsuit
+        "n03710721": "tank suit"        # Swimsuit
+        }
+
+        if label in special_cases:
+            return special_cases[label]
+        
+        try:
+            offset = int(label[1:])
+            synset = wn.synset_from_pos_and_offset('n', offset)
+            return synset.lemma_names()[0].replace('_', ' ')
+        except Exception:
+            return label  # fallback if not found
+    else:
+        return label  # already readable
+    
 def common_group(groups):
     common_hypernyms = []
     hierarchy = {}
+    
     for group in groups:
         hierarchy[group] = []
         synsets = wn.synsets(group)
@@ -29,48 +52,118 @@ def common_group(groups):
         for hypernym in hierarchy[groups.pop()]:
             if all(hypernym in hypernyms for hypernyms in hierarchy.values()):
                 common_hypernyms.append(hypernym)
+    
     return common_hypernyms[::-1]
 
+def process_hierarchy(hierarchy_data,):
+    """Process the entire hierarchy, renaming clusters while preserving structure."""
+    return _rename_clusters(hierarchy_data)
 
 def get_all_leaf_names(node):
+    """Extract all leaf node names from a cluster hierarchy."""
     if "children" not in node:
+        # Only return actual object names, not cluster names
         if "cluster" not in node["name"]:
             return [node["name"]]
         return []
+    
     names = []
     for child in node["children"]:
         names.extend(get_all_leaf_names(child))
     return names
+
+def _rename_clusters(tree):
+    """
+    Traverse the tree in BFS manner and rename clusters based on child names,
+    which can be leaves or already-renamed clusters.
+    """
+    used_names = set()
+    all_leaf_names = {leaf.lower() for leaf in get_all_leaf_names(tree)}
     
+    queue = deque()
+    queue.append(tree)
 
-def process_hierarchy(hierarchy_data):
-    return _rename_clusters(hierarchy_data)
+    # BFS traversal, we store nodes with children in postprocess queue
+    postprocess_nodes = []
 
+    while queue:
+        node = queue.popleft()
+        if "children" in node:
+            queue.extend(node["children"])
+            postprocess_nodes.append(node)  # non-leaf clusters to process after children
 
-def _get_top_synsets(phrase: str, pos=wn.NOUN, max_senses: int = 15) -> list[wn.synset]:
+    # Process clusters in reverse BFS (bottom-up)
+    for node in reversed(postprocess_nodes):
+        if "cluster" not in node["name"]:
+            continue  # already renamed
+
+        # Collect child names (renamed or original leaves)
+        child_names = [child["name"] for child in node["children"] if "name" in child]
+        
+        # Get hypernym candidate from child names
+        candidate = find_common_hypernyms(child_names)
+        if candidate:
+            # Ensure it’s unique
+            base = candidate
+            unique = base
+            idx = 1
+            while unique.lower() in all_leaf_names or unique.lower() in {n.lower() for n in used_names}:
+                idx += 1
+                unique = f"{base}_{idx}"
+            node["name"] = unique
+            used_names.add(unique)
+    
+    return tree
+
+def _get_top_synsets(
+    phrase: str,
+    pos=wn.NOUN,
+    max_senses: int = 15
+) -> list[wn.synset]:
+    """
+    Return up to `max_senses` synsets for `phrase`.
+    - Replaces spaces/underscores so WordNet can match “pickup truck” or “aquarium_fish”.
+    - WordNet already orders synsets by frequency, so we take only the first few.
+    """
     lemma = phrase.strip().lower().replace(" ", "_")
     syns = wn.synsets(lemma, pos=pos)
     return syns[:max_senses] if syns else []
 
 
+# ---------------------------------------------------
+# Core: compute the single best hypernym for a set of words
+# ---------------------------------------------------
 def _find_best_common_hypernym(
     leaves: list[str],
     max_senses_per_word: int = 5,
-    banned_lemmas: set[str] = None
-) -> Optional[str]:
-    
+    banned_lemmas: set[str] = None,
+) -> str | None:
+    """
+    1. For each leaf in `leaves`, fetch up to `max_senses_per_word` synsets.
+    2. For EVERY pair of leaves (w1, w2), for EVERY combination of synset ∈ synsets(w1) × synsets(w2),
+       call syn1.lowest_common_hypernyms(syn2) → yields a list of shared hypernyms.
+       Tally them in `lch_counter`.
+    3. Sort the candidates by (frequency, min_depth) so we pick the most-specific, most-common ancestor.
+    4. Filter out overly generic lemmas (like “entity”, “object”) unless NOTHING else remains.
+    5. Return the best lemma_name (underscore → space, capitalized).
+    """
     if banned_lemmas is None:
         banned_lemmas = {"entity", "object", "physical_entity", "thing", "Object", "Whole", "Whole", "Physical_entity", "Thing", "Entity", "Artifact"}
-    
+
+
+    # 1. Map each leaf → up to `max_senses_per_word` synsets
     word_to_synsets: dict[str, list[wn.synset]] = {}
     for w in leaves:
         syns = _get_top_synsets(w, wn.NOUN, max_senses_per_word)
         if syns:
             word_to_synsets[w] = syns
 
+    # If fewer than 2 words have ANY synsets, we cannot get a meaningful common hypernym
     if len(word_to_synsets) < 2:
         return None
 
+    # 2. For each pair of distinct leaves w1, w2, do ALL combinations of synset₁ × synset₂
+    #    and tally lowest_common_hypernyms
     lch_counter: Counter[wn.synset] = Counter()
     words_list = list(word_to_synsets.keys())
 
@@ -82,7 +175,6 @@ def _find_best_common_hypernym(
             try:
                 common = s1.lowest_common_hypernyms(s2)
             except Exception as e:
-                print(f"Error computing LCH({s1.name()}, {s2.name()}): {e}")
                 continue
             for hyp in common:
                 lch_counter[hyp] += 1
@@ -90,12 +182,14 @@ def _find_best_common_hypernym(
     if not lch_counter:
         return None
 
+    # 3. Sort candidates by (frequency, min_depth) descending
     candidates = sorted(
         lch_counter.items(),
         key=lambda item: (item[1], item[0].min_depth()),
         reverse=True
     )
 
+    # 4. Filter out generic lemma_names unless NOTHING else remains
     filtered: list[tuple[wn.synset, int]] = []
     for syn, freq in candidates:
         lemma = syn.name().split(".")[0].lower()
@@ -103,75 +197,61 @@ def _find_best_common_hypernym(
             continue
         filtered.append((syn, freq))
 
+    # If every candidate was filtered out, allow the first generic anyway
     if not filtered:
         filtered = candidates
 
     best_synset, best_freq = filtered[0]
     best_label = (best_synset.name().split(".")[0].replace(" ", "_")).lower()
+    
     return best_label
 
+
+# ---------------------------------------------------
+# Public version: branching on single vs. multiple leaves
+# ---------------------------------------------------
 def find_common_hypernyms(
     words: list[str],
     abstraction_level: int = 0,
-) -> Optional[str]:
-  
+) -> str | None:
+    """
+    Improved drop-in replacement for your old `find_common_hypernyms`.
+    1. Normalize each word (underscores ↔ spaces, lowercase) and filter out anything containing "Cluster".
+    2. If there’s exactly one valid leaf, pick its first hypernym (one level up) unless it’s “entity”.
+    3. If there are 2+ leaves, call _find_best_common_hypernym on them.
+    """
+
     clean_leaves = [
+        # w.strip().lower().replace(" ", "_")
         re.sub(r'_\d+$', '', w.strip().lower().replace(" ", "_"))
         for w in words
         if w and "cluster" not in w.lower()
     ]
 
+    # If nothing remains, bail out
     if not clean_leaves:
         return None
 
+    # Single-word case: pick its immediate hypernym (second-to-bottom in the hypernym path)
     if len(clean_leaves) == 1:
         word = clean_leaves[0]
         synsets = _get_top_synsets(word, wn.NOUN, max_senses=10)
         if not synsets:
             return None
 
+        # Choose the first sense’s longest hypernym path, then take one level up from leaf sense.
         paths = synsets[0].hypernym_paths()  # list of lists
         if not paths:
             return None
 
         longest_path = max(paths, key=lambda p: len(p))
+        # If path has at least 2 nodes, candidate = one level above the leaf sense
         if len(longest_path) >= 2:
             candidate = longest_path[-2]
             name = (candidate.name().split(".")[0].replace(" ", "_")).lower()
             if name.lower() not in {word, "entity"}:
                 return name
         return None
-    return _find_best_common_hypernym(clean_leaves, max_senses_per_word=5)
-
-
-def _rename_clusters(tree):
-    used_names = set()
-    all_leaf_names = {leaf.lower() for leaf in get_all_leaf_names(tree)}
-    queue = deque()
-    queue.append(tree)
-    postprocess_nodes = []
-
-    while queue:
-        node = queue.popleft()
-        if "children" in node:
-            queue.extend(node["children"])
-            postprocess_nodes.append(node) 
-
-    for node in reversed(postprocess_nodes):
-        if "cluster" not in node["name"]:
-            continue
 
-        child_names = [child["name"] for child in node["children"] if "name" in child]
-        candidate = find_common_hypernyms(child_names)
-
-        if candidate:
-            base = candidate
-            unique = base
-            idx = 1
-            while unique.lower() in all_leaf_names or unique.lower() in {n.lower() for n in used_names}:
-                idx += 1
-                unique = f"{base}_{idx}"
-            node["name"] = unique
-            used_names.add(unique)
-            
-    return tree
+    # 2+ leaves: use pairwise LCA approach
+    return _find_best_common_hypernym(clean_leaves, max_senses_per_word=5)

BETTER_NMA/white_box_testing.py

@@ -57,7 +57,7 @@ def get_white_box_analysis(edges_df_path, model_filename, dataset_str, source_la
     edges_data.load_dataframe()
     df = edges_data.get_dataframe()
 
-    whitebox_testing = WhiteBoxTesting(model_filename)
+    whitebox_testing = WhiteBoxTesting(model_filename, verbose=False)
     problematic_imgs_dict = whitebox_testing.find_problematic_images(
         source_labels, target_labels, df, dataset_str)
 

{BETTER_NMA-1.0.1.dist-info → BETTER_NMA-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: BETTER_NMA
-Version: 1.0.1
+Version: 1.0.5
 Summary: NMA: Dendrogram-based model analysis, white-box testing, and adversarial detection
 Author: BETTER_XAI
 Author-email: BETTERXAI2025@gmail.com

{BETTER_NMA-1.0.1.dist-info → BETTER_NMA-1.0.5.dist-info}/RECORD

@@ -2,28 +2,29 @@ BETTER_NMA/__init__.py,sha256=ePaQnto0n4hccz2490Z7bxwcbtONVAa6nWqg7SL4W1Y,428
 BETTER_NMA/adversarial_score.py,sha256=qgScTqS-aJ2q4kFom505hBtonVzKK67fGS09J1_-G3o,875
 BETTER_NMA/change_cluster_name.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 BETTER_NMA/detect_attack.py,sha256=s7YwTVMJFABSMt2aISR-zaIUxFaSWm9oODc9yF12KPY,4327
+BETTER_NMA/explaination_score.py,sha256=GWtncYjIj8UF94g1UxtNRnyK7Cvh3PqVcShle_vLhUM,2003
 BETTER_NMA/find_lca.py,sha256=UlyftOJmbSPuXzxvcheRb_IrdCqBsaSQHLchIRZIR-0,812
-BETTER_NMA/main.py,sha256=73MH7v6LAs2kQexumLBDykVnhH774P-HPrnhV1LZ7MM,11318
-BETTER_NMA/nma_creator.py,sha256=M-LlZGRkxhGYLHpaXTNoZj9AUH7uvev7hq7tbILWMLI,5137
-BETTER_NMA/plot.py,sha256=nj2ca-ybzGMlo6HhCngyjGUNaJDmfsPxF5ad9xpxzvE,4383
+BETTER_NMA/main.py,sha256=c-JZX3F2Ozh-ctVtlnB19hN4gptxt-4wQsecBzD-fSU,12258
+BETTER_NMA/nma_creator.py,sha256=mJRRFX2d5pUXORT0jKpMV5QW8FFqn1bJgUmyqPVnMQA,5282
+BETTER_NMA/plot.py,sha256=ySNXrlQgwV6gm2Dw6yWT-dfrY7A7mRTJNUgsd6sOxic,3954
 BETTER_NMA/query_image.py,sha256=13AQ9-8QdzaIwH5-ELX3z3iJBP8nTDe-SMtwQve-1ek,906
 BETTER_NMA/train_adversarial_detector.py,sha256=nMaQ-Pm2vP84qNR1GoKQiVPpmMC3rdorzDMf5gDwKTE,977
-BETTER_NMA/white_box_testing.py,sha256=zfhK8G-2cJH1AMevPywVnc05IhSqttf3YxQ6abdpM78,3524
+BETTER_NMA/white_box_testing.py,sha256=VZ5pImXUOpM6jWMOoIkTWymwPCsev75zQ2SudSJ0frw,3539
 BETTER_NMA/utilss/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 BETTER_NMA/utilss/models_utils.py,sha256=gBXY2LFH4iR-2GZmHeUnnB5n9t3VdjIc9sugHDrD3AM,671
-BETTER_NMA/utilss/photos_uitls.py,sha256=mPe0zXTqN1RvkfDf0eiwzsniybicbomBkCQdTA-W8qQ,3160
-BETTER_NMA/utilss/photos_utils.py,sha256=K6VWOSo3fY00LIW0yZPrI0MH0NrY5SPZh46RrtF0mj0,4406
+BETTER_NMA/utilss/photos_uitls.py,sha256=wxmIIKFgAKYkcYaK95UMjtY-LZS6NDVveKrHBQV8Q70,3166
+BETTER_NMA/utilss/photos_utils.py,sha256=4EjDHbMjrJ8P9y-X4H05P4wez4uKNit60UGnu3sKsys,4412
 BETTER_NMA/utilss/verbal_explanation.py,sha256=_hrYZUjBUYOfuGr7t5r-DACooR5d60dRtGfUj7FbeZw,549
-BETTER_NMA/utilss/wordnet_utils.py,sha256=_A_gbdR7tf5tiyN2Oe5sB4vvBkWnr4KUl5e9iq5ft8c,5535
+BETTER_NMA/utilss/wordnet_utils.py,sha256=77qcmEQH3Krd1T8dQY-IXVpaEgfwlw406XRk4zYsghw,9482
 BETTER_NMA/utilss/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-BETTER_NMA/utilss/classes/adversarial_dataset.py,sha256=6LrL_KrmUYuhsSGTmV1DBuV2sVAR9nIydUAW6FbPR8c,2447
+BETTER_NMA/utilss/classes/adversarial_dataset.py,sha256=LKmyseQetyBdoKrl7Q4MaTc7EzMZcMgqNdtCsdAvKHA,2299
 BETTER_NMA/utilss/classes/adversarial_detector.py,sha256=BE_SxNEwcvuHERBiefefOmk1k6NJSo6juehkAjkEHuQ,2331
 BETTER_NMA/utilss/classes/dendrogram.py,sha256=vtKBFfwzcz8k01Goc83pZlWC2pO86endTJURlkUWVQI,5141
 BETTER_NMA/utilss/classes/edges_dataframe.py,sha256=q-RQ6beOeZeIgdEzwi8T5Ag2NBFySv7-ITD5m989nl4,1896
-BETTER_NMA/utilss/classes/score_calculator.py,sha256=4ZyTA2BnWh2XhnjA5AoYAbbA7AOCDvUikToz6m5m4nM,6005
-BETTER_NMA/utilss/classes/whitebox_testing.py,sha256=4WSEjQ5gl6f8xzWADAagZ3WtMHE889rW-zcYld9REnw,1367
+BETTER_NMA/utilss/classes/score_calculator.py,sha256=zgZaFgFJeok2RzXFm9OE5pOuXY3euIXEiLGI44q30JM,5927
+BETTER_NMA/utilss/classes/whitebox_testing.py,sha256=_WsJWUSSb7Ndvzw2ftM7QKXiz_8NXOMS3njBKPAM4Rw,1542
 BETTER_NMA/utilss/classes/preprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-BETTER_NMA/utilss/classes/preprocessing/batch_predictor.py,sha256=baUsz_oj_JLEpUoy_o08m_AK0uaWb5RB_cavk5Itg1A,946
+BETTER_NMA/utilss/classes/preprocessing/batch_predictor.py,sha256=3-hs9Mr30B0n9PQZE20-3RoLlsS5dw56yQX2MU4UnT4,1070
 BETTER_NMA/utilss/classes/preprocessing/graph_builder.py,sha256=ILumiBY9BUIOxrIvq8C-8n945pK-t94Et6gZwJB-364,1672
 BETTER_NMA/utilss/classes/preprocessing/heap_processor.py,sha256=KblmkVWVfMYtpZa4Wy1Ry0lVfdSr6h8LySt4S-lvIGo,1064
 BETTER_NMA/utilss/classes/preprocessing/hierarchical_clustering_builder.py,sha256=YAIElJS_fSffIb3D2N1OZu9U6z7RYrHQTfB6bH4-VPI,4027
@@ -32,7 +33,7 @@ BETTER_NMA/utilss/classes/preprocessing/z_builder.py,sha256=T8ETfL7mMOgEj7oYNsw6
 BETTER_NMA/utilss/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 BETTER_NMA/utilss/enums/explanation_method.py,sha256=Ang-rjvxO4AJ1IH4mwS8sNpSwt9jn3PlqFbPPT-R9I8,150
 BETTER_NMA/utilss/enums/heap_types.py,sha256=0z1d2qu1ZCbpWRXKD1dTopn3M4G1CxRQW9HWxVxyPIA,88
-BETTER_NMA-1.0.1.dist-info/METADATA,sha256=F4ZFsCJpeZVeYLJ2sMlDEC1c-gZTdvyfJvUxGxEQ2HQ,5100
-BETTER_NMA-1.0.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-BETTER_NMA-1.0.1.dist-info/top_level.txt,sha256=SVRNqWPvCnynWVyXNAYnf9CSQIvMAvE6iyyiGHodQgY,11
-BETTER_NMA-1.0.1.dist-info/RECORD,,
+BETTER_NMA-1.0.5.dist-info/METADATA,sha256=oqz6IAT6kY-q94bKDTGFxSxAXI47J1P_GWcZQXKeaxM,5100
+BETTER_NMA-1.0.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+BETTER_NMA-1.0.5.dist-info/top_level.txt,sha256=SVRNqWPvCnynWVyXNAYnf9CSQIvMAvE6iyyiGHodQgY,11
+BETTER_NMA-1.0.5.dist-info/RECORD,,