BETTER-NMA 1.0.0__py3-none-any.whl

BETTER_NMA/utilss/wordnet_utils.py

@@ -0,0 +1,177 @@
+from nltk.corpus import wordnet as wn
+from typing import Optional
+import re
+from collections import deque
+from itertools import combinations, product
+from collections import Counter
+
+def folder_name_to_number(folder_name):
+    synsets = wn.synsets(folder_name)
+    if synsets:
+        offset = synsets[0].offset()        
+        folder_number = 'n{:08d}'.format(offset)
+        return folder_number
+    
+def common_group(groups):
+    common_hypernyms = []
+    hierarchy = {}
+    for group in groups:
+        hierarchy[group] = []
+        synsets = wn.synsets(group)
+        if synsets:
+            hypernyms = synsets[0].hypernym_paths()
+            for path in hypernyms:
+                hierarchy[group].extend([node.name().split('.')[0] for node in path])
+                
+    if len(hierarchy) == 1:
+        common_hypernyms = list(hierarchy.values())[0]
+    else:
+        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 get_all_leaf_names(node):
+    if "children" not in node:
+        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 process_hierarchy(hierarchy_data):
+    return _rename_clusters(hierarchy_data)
+
+
+def _get_top_synsets(phrase: str, pos=wn.NOUN, max_senses: int = 15) -> list[wn.synset]:
+    lemma = phrase.strip().lower().replace(" ", "_")
+    syns = wn.synsets(lemma, pos=pos)
+    return syns[:max_senses] if syns else []
+
+
+def _find_best_common_hypernym(
+    leaves: list[str],
+    max_senses_per_word: int = 5,
+    banned_lemmas: set[str] = None
+) -> Optional[str]:
+    
+    if banned_lemmas is None:
+        banned_lemmas = {"entity", "object", "physical_entity", "thing", "Object", "Whole", "Whole", "Physical_entity", "Thing", "Entity", "Artifact"}
+    
+    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 len(word_to_synsets) < 2:
+        return None
+
+    lch_counter: Counter[wn.synset] = Counter()
+    words_list = list(word_to_synsets.keys())
+
+    for w1, w2 in combinations(words_list, 2):
+        syns1 = word_to_synsets[w1]
+        syns2 = word_to_synsets[w2]
+
+        for s1, s2 in product(syns1, syns2):
+            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
+
+    if not lch_counter:
+        return None
+
+    candidates = sorted(
+        lch_counter.items(),
+        key=lambda item: (item[1], item[0].min_depth()),
+        reverse=True
+    )
+
+    filtered: list[tuple[wn.synset, int]] = []
+    for syn, freq in candidates:
+        lemma = syn.name().split(".")[0].lower()
+        if lemma in banned_lemmas:
+            continue
+        filtered.append((syn, freq))
+
+    if not filtered:
+        filtered = candidates
+
+    best_synset, best_freq = filtered[0]
+    best_label = (best_synset.name().split(".")[0].replace(" ", "_")).lower()
+    return best_label
+
+def find_common_hypernyms(
+    words: list[str],
+    abstraction_level: int = 0,
+) -> Optional[str]:
+  
+    clean_leaves = [
+        re.sub(r'_\d+$', '', w.strip().lower().replace(" ", "_"))
+        for w in words
+        if w and "cluster" not in w.lower()
+    ]
+
+    if not clean_leaves:
+        return None
+
+    if len(clean_leaves) == 1:
+        word = clean_leaves[0]
+        synsets = _get_top_synsets(word, wn.NOUN, max_senses=10)
+        if not synsets:
+            return None
+
+        paths = synsets[0].hypernym_paths()  # list of lists
+        if not paths:
+            return None
+
+        longest_path = max(paths, key=lambda p: len(p))
+        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

BETTER_NMA/white_box_testing.py

@@ -0,0 +1,101 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from .utilss.classes.whitebox_testing import WhiteBoxTesting
+from .utilss.classes.edges_dataframe import EdgesDataframe
+from .utilss.photos_utils import encode_image_to_base64
+
+def visualize_problematic_images(x_train, problematic_imgs_dict, max_display=5):
+    count = 0
+    for image_id, matches in problematic_imgs_dict.items():
+        if count >= max_display:
+            break
+
+        image = x_train[image_id]
+
+        plt.figure(figsize=(8, 6))
+        plt.imshow(image.astype("uint8"))
+        plt.title(f"Image ID: {image_id}")
+        plt.axis('off')
+        plt.show()
+
+        print(f"Image ID: {image_id}")
+        print("Matches:")
+        for match in matches:
+            print(f"  {match[0]} -> {match[1]}: {match[2]:.8f}")
+        print("-" * 30)
+
+        count += 1
+
+def analyze_white_box_results(problematic_imgs_dict, x_train=None, encode_images=True):
+    results = []
+
+    for image_id, matches in problematic_imgs_dict.items():
+        result_item = {
+            "image_id": str(image_id),
+            "matches": matches,
+            "num_matches": len(matches)
+        }
+
+        if encode_images and x_train is not None and isinstance(image_id, int) and image_id < len(x_train):
+            img = x_train[image_id]
+            if img.max() <= 1.0:
+                img = (img * 255).astype(np.uint8)
+
+            result_item["image"] = encode_image_to_base64(img)
+
+        results.append(result_item)
+
+    return results
+
+def get_white_box_analysis(edges_df_path, model_filename, dataset_str, source_labels, target_labels, x_train=None, get_image_by_id_func=None):
+    if not edges_df_path or not model_filename or not source_labels or not target_labels:
+        raise ValueError("Missing required parameters")
+
+    edges_data = EdgesDataframe(model_filename, edges_df_path)
+    edges_data.load_dataframe()
+    df = edges_data.get_dataframe()
+
+    whitebox_testing = WhiteBoxTesting(model_filename)
+    problematic_imgs_dict = whitebox_testing.find_problematic_images(
+        source_labels, target_labels, df, dataset_str)
+
+    imgs_list = []
+
+    for image_id, matches in problematic_imgs_dict.items():
+        try:
+            if x_train is not None and isinstance(image_id, int) and image_id < len(x_train):
+                img = x_train[image_id]
+                image_filename = str(image_id)
+            elif get_image_by_id_func is not None:
+                img, image_filename = get_image_by_id_func(image_id, dataset_str)
+            else:
+                print(f"Cannot retrieve image {image_id}: no data source provided")
+                continue
+
+            if img.max() <= 1.0:
+                img = (img * 255).astype(np.uint8)
+
+            original_image_base64 = encode_image_to_base64(img)
+
+            imgs_list.append({
+                "image": original_image_base64,
+                "image_id": image_filename,
+                "matches": matches,
+            })
+        except Exception as e:
+            print(f"Error processing image {image_id}: {str(e)}")
+
+    return imgs_list
+
+def save_white_box_results(results, output_path):
+    import json
+    with open(output_path, 'w') as f:
+        json.dump(results, f, indent=2)
+    print(f"Results saved to: {output_path}")
+
+def load_white_box_results(input_path):
+    import json
+    with open(input_path, 'r') as f:
+        return json.load(f)

BETTER_NMA-1.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: BETTER_NMA
+Version: 1.0.0
+Requires-Dist: tensorflow
+Requires-Dist: pandas
+Requires-Dist: igraph
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: matplotlib
+Requires-Dist: nltk
+Requires-Dist: keras

BETTER_NMA-1.0.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+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/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/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/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/verbal_explanation.py,sha256=_hrYZUjBUYOfuGr7t5r-DACooR5d60dRtGfUj7FbeZw,549
+BETTER_NMA/utilss/wordnet_utils.py,sha256=_A_gbdR7tf5tiyN2Oe5sB4vvBkWnr4KUl5e9iq5ft8c,5535
+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_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/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/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
+BETTER_NMA/utilss/classes/preprocessing/tree_node.py,sha256=ELG--4ekRSPGCRWwvs8IsEC88ytaXQuGs4lnyLqriLE,2195
+BETTER_NMA/utilss/classes/preprocessing/z_builder.py,sha256=T8ETfL7mMOgEj7oYNsw6-uUB0zGPLx7I26WEcYbQaw4,3553
+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.0.dist-info/METADATA,sha256=XouVuHepQ1tDjgxeQKesgEREOrVzN9oFP-iYBafHNfU,251
+BETTER_NMA-1.0.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+BETTER_NMA-1.0.0.dist-info/top_level.txt,sha256=SVRNqWPvCnynWVyXNAYnf9CSQIvMAvE6iyyiGHodQgY,11
+BETTER_NMA-1.0.0.dist-info/RECORD,,

BETTER_NMA-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

BETTER_NMA-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+BETTER_NMA