BETTER-NMA 1.0.2__tar.gz → 1.0.5__tar.gz

{better_nma-1.0.2 → better_nma-1.0.5}/BETTER_NMA/main.py

@@ -11,6 +11,8 @@ 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):
@@ -37,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)
@@ -82,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):
@@ -102,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)
 

{better_nma-1.0.2 → better_nma-1.0.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-1.0.2 → better_nma-1.0.5}/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-1.0.2 → better_nma-1.0.5}/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:
@@ -18,7 +19,8 @@ class BatchPredictor:
             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-1.0.2 → better_nma-1.0.5}/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-1.0.2 → better_nma-1.0.5}/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-1.0.2 → better_nma-1.0.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.2 → better_nma-1.0.5}/BETTER_NMA.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: BETTER_NMA
-Version: 1.0.2
+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.2 → better_nma-1.0.5}/BETTER_NMA.egg-info/SOURCES.txt

@@ -39,4 +39,5 @@ BETTER_NMA/utilss/classes/preprocessing/tree_node.py
 BETTER_NMA/utilss/classes/preprocessing/z_builder.py
 BETTER_NMA/utilss/enums/__init__.py
 BETTER_NMA/utilss/enums/explanation_method.py
-BETTER_NMA/utilss/enums/heap_types.py
+BETTER_NMA/utilss/enums/heap_types.py
+tests/test_main.py

{better_nma-1.0.2 → better_nma-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: BETTER_NMA
-Version: 1.0.2
+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.2 → better_nma-1.0.5}/setup.py

@@ -8,7 +8,7 @@ except FileNotFoundError:
 
 setup(
     name="BETTER_NMA",
-    version="1.0.2",
+    version="1.0.5",
     author="BETTER_XAI",
     author_email="BETTERXAI2025@gmail.com",
     description="NMA: Dendrogram-based model analysis, white-box testing, and adversarial detection",

better_nma-1.0.5/tests/test_main.py

@@ -0,0 +1,280 @@
+"""
+Test script for BETTER_NMA package main functionalities with CIFAR-100
+Testing: nma.plot, plot_sub_dendrogram, get_tree_as_dict, white_box_testing, find_lca
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from BETTER_NMA import NMA
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.applications.resnet50 import preprocess_input
+import json
+import matplotlib.pyplot as plt
+
+# Suppress TensorFlow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+print("TF version:", tf.__version__)
+
+def test_cifar100_nma():
+    """Test all NMA functionalities with CIFAR-100"""
+    
+    print("="*60)
+    print("Testing NMA with CIFAR-100 Dataset")
+    print("="*60)
+    
+    # 1. Load CIFAR-100 dataset
+    print("\n1. Loading CIFAR-100 dataset...")
+    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar100.load_data()
+    
+    labels = [
+        'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle', 'bicycle', 'bottle',
+        'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel', 'can', 'castle', 'caterpillar', 'cattle',
+        'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
+        'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'keyboard',
+        'lamp', 'lawn_mower', 'leopard', 'lion', 'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain',
+        'mouse', 'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear', 'pickup_truck', 'pine_tree',
+        'plain', 'plate', 'poppy', 'porcupine', 'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket',
+        'rose', 'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake', 'spider',
+        'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table', 'tank', 'telephone', 'television', 'tiger', 'tractor',
+        'train', 'trout', 'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman', 'worm'
+    ]
+    
+    # Use a small subset for faster testing (first 500 samples)
+    x_train = x_train[:500]
+    y_train = y_train[:500]
+    
+    # Preprocess data
+    x_train = preprocess_input(x_train)
+    y_train = y_train.astype(int).flatten()
+    y_train_strings = [labels[i] for i in y_train]
+    
+    print(f"x_train shape: {x_train.shape}")
+    print(f"y_train_strings example: {y_train_strings[:5]}")
+    
+    # 2. Load or create model
+    print("\n2. Loading CIFAR-100 model...")
+    
+    # Check if model exists
+    model_path = "tests/cifar100_resnet.keras"
+    if os.path.exists(model_path):
+        try:
+            cifar100_model = tf.keras.models.load_model(model_path)
+            print(f"Loaded model from: {model_path}")
+        except Exception as e:
+            print(f"Could not load saved model: {e}")
+            # Create simple model for testing
+            cifar100_model = tf.keras.Sequential([
+                tf.keras.layers.Input(shape=(32, 32, 3)),
+                tf.keras.layers.Conv2D(32, 3, activation='relu'),
+                tf.keras.layers.GlobalAveragePooling2D(),
+                tf.keras.layers.Dense(100, activation='softmax')
+            ])
+            cifar100_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
+            print("Created simple test model")
+    else:
+        print("Creating simple model for testing...")
+        cifar100_model = tf.keras.Sequential([
+            tf.keras.layers.Input(shape=(32, 32, 3)),
+            tf.keras.layers.Conv2D(32, 3, activation='relu'),
+            tf.keras.layers.GlobalAveragePooling2D(),
+            tf.keras.layers.Dense(100, activation='softmax')
+        ])
+        cifar100_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
+        print("Created simple test model")
+    
+    # 3. Initialize NMA with similarity explanation method
+    print("\n3. Initializing NMA...")
+    try:
+        nma = NMA(
+            x_train=x_train,
+            y_train=y_train_strings,
+            labels=labels,
+            model=cifar100_model,
+            explanation_method="similarity",
+            top_k=4,
+            min_confidence=0.8,
+            batch_size=32,
+            save_connections=True  # Required for white-box testing
+        )
+        print("NMA initialized successfully")
+    except Exception as e:
+        print(f"Error initializing NMA: {e}")
+        return None
+    
+    print("\n" + "="*60)
+    print("TESTING NMA FUNCTIONALITIES")
+    print("="*60)
+    
+    # Test 1: nma.plot() - Full dendrogram
+    print("\n📊 Test 1: nma.plot() - Full dendrogram")
+    print("-"*40)
+    try:
+        nma.plot(title="CIFAR-100 Full Dendrogram", figsize=(20, 20))
+        print("✓ Full dendrogram plotted")
+        plt.close('all')  # Close plots to save memory
+    except Exception as e:
+        print(f"✗ Error: {e}")
+    
+    # Test 2: nma.plot() with sub_labels
+    print("\n📊 Test 2: nma.plot() with sub_labels")
+    print("-"*40)
+    try:
+        # Test with tree-related labels
+        tree_labels = ["maple_tree", "oak_tree", "palm_tree", "pine_tree", "willow_tree", "forest"]
+        nma.plot(sub_labels=tree_labels, title="Tree Classes Sub-Dendrogram", figsize=(12, 8))
+        print(f"✓ Sub-dendrogram plotted for: {tree_labels}")
+        plt.close('all')
+    except Exception as e:
+        print(f"✗ Error: {e}")
+    
+    # Test 3: nma.plot_sub_dendrogram()
+    print("\n📊 Test 3: nma.plot_sub_dendrogram()")
+    print("-"*40)
+    try:
+        # Test with people-related labels
+        people_labels = ["baby", "boy", "girl", "man", "woman"]
+        nma.plot_sub_dendrogram(sub_labels=people_labels, title="People Classes", figsize=(10, 6))
+        print(f"✓ plot_sub_dendrogram worked for: {people_labels}")
+        plt.close('all')
+    except Exception as e:
+        print(f"✗ Error: {e}")
+    
+    # Test 4: nma.get_tree_as_dict()
+    print("\n📋 Test 4: nma.get_tree_as_dict()")
+    print("-"*40)
+    try:
+        # Full tree
+        tree_dict = nma.get_tree_as_dict()
+        print("✓ Got full tree as dictionary")
+        print(f"  Keys: {list(tree_dict.keys())}")
+        if 'name' in tree_dict:
+            print(f"  Root name: {tree_dict['name']}")
+        
+        # Sub-tree with animal labels
+        animal_labels = ["bear", "beaver", "bee", "beetle", "butterfly"]
+        sub_tree_dict = nma.get_tree_as_dict(sub_labels=animal_labels)
+        print(f"✓ Got sub-tree for: {animal_labels}")
+        
+        # Show structure
+        tree_json = json.dumps(sub_tree_dict, indent=2)
+        print(f"  Sub-tree preview (first 200 chars): {tree_json[:200]}...")
+    except Exception as e:
+        print(f"✗ Error: {e}")
+    
+    # Test 5: nma.find_lca()
+    print("\n🔍 Test 5: nma.find_lca() - Finding Lowest Common Ancestors")
+    print("-"*40)
+    
+    test_pairs = [
+        ("woman", "girl"),          # People/female cluster
+        ("man", "boy"),             # People/male cluster
+        ("maple_tree", "oak_tree"), # Tree cluster
+        ("bee", "beetle"),          # Insect cluster
+        ("apple", "pear"),          # Fruit cluster
+        ("tulip", "orchid"),        # Flower cluster
+    ]
+    
+    for label1, label2 in test_pairs:
+        try:
+            lca = nma.find_lca(label1, label2)
+            print(f"✓ LCA of '{label1}' and '{label2}': {lca}")
+        except Exception as e:
+            print(f"✗ Error finding LCA for {label1}-{label2}: {e}")
+    
+    # Test 6: nma.white_box_testing()
+    print("\n🧪 Test 6: nma.white_box_testing()")
+    print("-"*40)
+    try:
+        # Test as in Kaggle example
+        source_labels = ["beetle", "tulip"]
+        target_labels = ["bee", "orchid"]
+        
+        print(f"  Testing: {source_labels} → {target_labels}")
+        
+        # Without analysis
+        problematic_imgs = nma.white_box_testing(
+            source_labels=source_labels,
+            target_labels=target_labels,
+            analyze_results=False
+        )
+        
+        print(f"✓ White-box testing completed")
+        print(f"  Found {len(problematic_imgs)} problematic images")
+        
+        if problematic_imgs:
+            # Show first problematic image
+            img_id = list(problematic_imgs.keys())[0]
+            matches = problematic_imgs[img_id]
+            print(f"  Example - Image {img_id}: {len(matches)} matches")
+            for match in matches[:3]:
+                print(f"    {match[0]} → {match[1]}: {match[2]:.4f}")
+        
+        # With analysis
+        analyzed_results = nma.white_box_testing(
+            source_labels=source_labels,
+            target_labels=target_labels,
+            analyze_results=True,
+            x_train=x_train,
+            encode_images=False
+        )
+        print(f"✓ Analysis completed: {len(analyzed_results)} results")
+        
+    except Exception as e:
+        print(f"✗ Error: {e}")
+    
+    # Test 7: nma.get_white_box_analysis()
+    print("\n🧪 Test 7: nma.get_white_box_analysis()")
+    print("-"*40)
+    try:
+        source_labels = ["woman", "girl"]
+        target_labels = ["man", "boy"]
+        
+        print(f"  Testing: {source_labels} → {target_labels}")
+        
+        analysis = nma.get_white_box_analysis(
+            source_labels=source_labels,
+            target_labels=target_labels,
+            x_train=x_train
+        )
+        
+        print(f"✓ Analysis completed: {len(analysis)} entries")
+        if analysis:
+            print(f"  Entry keys: {list(analysis[0].keys())}")
+            
+    except Exception as e:
+        print(f"✗ Error: {e}")
+    
+    print("\n" + "="*60)
+    print("TEST SUMMARY")
+    print("="*60)
+    
+    print("\n✅ Tested NMA functionalities:")
+    print("  1. nma.plot() - Full and sub dendrograms")
+    print("  2. nma.plot_sub_dendrogram() - Specific label subsets")
+    print("  3. nma.get_tree_as_dict() - Tree structure as dictionary")
+    print("  4. nma.find_lca() - Finding lowest common ancestors")
+    print("  5. nma.white_box_testing() - Identifying problematic images")
+    print("  6. nma.get_white_box_analysis() - Detailed analysis")
+    
+    return nma
+
+if __name__ == "__main__":
+    try:
+        print("Starting CIFAR-100 NMA tests...")
+        print("Using subset of 500 samples for faster testing\n")
+        
+        nma = test_cifar100_nma()
+        
+        if nma:
+            print("\n✅ All tests completed successfully!")
+        else:
+            print("\n⚠ Tests completed with issues")
+        
+    except Exception as e:
+        print(f"\n❌ Fatal error: {e}")
+        import traceback
+        traceback.print_exc()