BETTER-NMA 1.0.0__py3-none-any.whl

BETTER_NMA/__init__.py

@@ -0,0 +1,15 @@
+from .main import NMA
+from .white_box_testing import (
+    visualize_problematic_images,
+    analyze_white_box_results,
+    get_white_box_analysis
+)
+from .white_box_testing import save_white_box_results, load_white_box_results
+
+__all__ = [
+    "NMA",
+    "visualize_problematic_images",
+    "analyze_white_box_results",
+    "get_white_box_analysis"
+]
+__all__ += ["save_white_box_results", "load_white_box_results"]

BETTER_NMA/adversarial_score.py

@@ -0,0 +1,19 @@
+from .utilss.classes.score_calculator import ScoreCalculator
+from .utilss.photos_utils import preprocess_loaded_image
+
+def get_adversarial_score(image, model, full_z, class_names, top_k=5):
+    """
+    Calculate the adversarial score for a given image using the provided model and score calculator.
+
+    Parameters:
+    - image: Preprocessed image ready for model prediction
+    - model: The neural network model used for predictions
+    - full_z: The full Z matrix from hierarchical clustering
+    - class_names: List of class names corresponding to model outputs
+    """
+
+    score_calculator = ScoreCalculator(full_z, class_names)
+    processed_img, _ = preprocess_loaded_image(model, image)
+    predictions = model.predict(processed_img, verbose=0)[0]
+    score = score_calculator.calculate_adversarial_score(predictions, top_k=top_k)
+    return score

BETTER_NMA/detect_attack.py

@@ -0,0 +1,108 @@
+from .utilss.classes.score_calculator import ScoreCalculator
+from .utilss.photos_utils import preprocess_loaded_image
+from .utilss.models_utils import get_top_k_predictions
+import matplotlib.pyplot as plt
+
+def plot_detection_result(detection_result, figsize=(12, 8), top_k=5):
+    """
+    Plot the detection result with image, predictions, and detection status.
+    
+    Parameters:
+    - detection_result: Dictionary with keys 'image', 'predictions', 'result', 'probability'
+    - figsize: Tuple for figure size
+    - top_k: Number of top predictions to display
+    """
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+    
+    # Plot the image
+    ax1.imshow(detection_result['image'])
+    ax1.axis('off')
+    ax1.set_title('Input Image', fontsize=14, fontweight='bold')
+    
+    # Plot predictions and detection result
+    predictions = detection_result['predictions'][:top_k]
+    
+    # Handle both tuple and dictionary formats
+    if predictions and isinstance(predictions[0], tuple):
+        # If predictions are tuples (class_name, probability)
+        classes = [pred[0] for pred in predictions]
+        probabilities = [pred[1] for pred in predictions]
+    else:
+        # If predictions are dictionaries
+        classes = [pred['class'] for pred in predictions]
+        probabilities = [pred['probability'] for pred in predictions]
+    
+    # Create bar plot for predictions
+    bars = ax2.barh(range(len(classes)), probabilities, color='skyblue')
+    ax2.set_yticks(range(len(classes)))
+    ax2.set_yticklabels(classes, fontsize=10)
+    ax2.set_xlabel('Probability', fontsize=12)
+    ax2.set_title(f'Top {top_k} Predictions', fontsize=14, fontweight='bold')
+    ax2.set_xlim(0, 1)
+    
+    # Add probability values on bars
+    for i, (bar, prob) in enumerate(zip(bars, probabilities)):
+        ax2.text(prob + 0.01, i, f'{prob:.3f}', 
+                va='center', fontsize=9)
+    
+    # Add detection result as text
+    detection_status = detection_result['result']
+    detection_prob = detection_result['probability']
+    
+    # Color based on detection result
+    status_color = 'red' if detection_status == 'Adversarial' else 'green'
+    
+    # Add detection result text box
+    textstr = f'Detection: {detection_status}\nConfidence: {detection_prob:.3f}'
+    props = dict(boxstyle='round', facecolor=status_color, alpha=0.3)
+    ax2.text(0.02, 0.98, textstr, transform=ax2.transAxes, fontsize=12,
+            verticalalignment='top', bbox=props, fontweight='bold')
+    
+    plt.tight_layout()
+    plt.show()
+
+def detect_adversarial_image(model, image, detector, Z_full, labels, plot_result=False):
+    """
+    Detect if an image is adversarial using the trained logistic regression detector.
+    
+    Parameters:
+    - model: The original model being attacked
+    - detector: The trained logistic regression detector
+    - Z_full: Hierarchical clustering data
+    - labels: List of class names
+    - image: The input image to check
+    - plot_result: Whether to plot the detection result (default: False)
+    
+    Returns:
+    - Dictionary with 'image', 'predictions', 'result', and 'probability'
+    """
+        
+    image_preprocessed, pil_image = preprocess_loaded_image(model, image)
+    score_calculator = ScoreCalculator(Z_full, labels)
+    
+    # Get predictions from the original model
+    preds = model.predict(image_preprocessed, verbose=0)
+    
+    # Calculate the adversarial score (or other features)
+    score = score_calculator.calculate_adversarial_score(preds[0])
+    
+    # Use the detector to classify the image
+    feature = [[score]]  # Wrap the score in a 2D array
+    label = detector.predict(feature)[0]  # Predict the label (0 = clean, 1 = adversarial)
+    proba = detector.predict_proba(feature)[0][1]  # Probability of being adversarial
+    detection_result = 'Adversarial' if label == 1 else 'Clean'
+
+    # Get top predictions for the image
+    image_predictions = get_top_k_predictions(model, image_preprocessed, labels)
+    
+    result = {
+        "image": pil_image,
+        "predictions": image_predictions,
+        "result": detection_result,
+        "probability": proba
+    }
+    
+    if plot_result:
+        plot_detection_result(result)
+    
+    return result

BETTER_NMA/find_lca.py

@@ -0,0 +1,21 @@
+from .utilss.classes.score_calculator import ScoreCalculator
+
+def get_lca(label1, label2, dendrogram, class_names):
+    """
+    Find the Lowest Common Ancestor (LCA) of two classes in a hierarchical clustering dendrogram.
+
+    Parameters:
+    - label1: Name of the first class
+    - label2: Name of the second class
+    - full_z: The full Z matrix from hierarchical clustering
+    - class_names: List of class names corresponding to model outputs
+
+    Returns:
+    - lca: The name of the lowest common ancestor class
+    """
+    score_calculator = ScoreCalculator(dendrogram.Z, class_names)
+    idx1 = class_names.index(label1)
+    idx2 = class_names.index(label2)
+    _, lca_idx = score_calculator.count_ancestors_to_lca(idx1, idx2)
+    lca = dendrogram.get_node_name(lca_idx)
+    return lca

BETTER_NMA/main.py

@@ -0,0 +1,285 @@
+import tempfile
+import os
+from .nma_creator import preprocessing
+from .plot import plot, plot_sub_dendrogram
+from .train_adversarial_detector import create_logistic_regression_detector
+from .utilss.classes.whitebox_testing import WhiteBoxTesting
+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 .adversarial_score import get_adversarial_score
+from .find_lca import get_lca
+
+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):
+        """
+        Initializes the NMA object with training data, model, and parameters.
+
+        Inputs:
+        - x_train: Training images (e.g., NumPy array).
+        - y_train: Training labels (e.g., list or array).
+        - labels: List of class labels (e.g., ['cat', 'dog']).
+        - model: Pre-trained model for predictions.
+        - explanation_method: Method for generating explanations.
+        - top_k: Number of top predictions to consider (default: 4).
+        - min_confidence: Minimum confidence threshold (default: 0.8).
+        - infinity: Value for infinity in calculations, usually the labels count (default: None).
+        - threshold: Threshold for clustering, depends on the model (default: 1e-6).
+        - save_connections: Whether to save edges dataframe, use True for white box testing (default: False).
+        - batch_size: Batch size for processing (default: 32).
+
+        Outputs: None (initializes the object).
+
+        Explanation: Sets up the dendrogram (visual explanation) and edges dataframe using preprocessing.
+        """
+        self.model = model
+        self.explanation_method = explanation_method
+        self.top_k = top_k
+        self.labels = 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)
+        print("NMA initialized")
+
+    ## plot functions: ##
+
+    def plot(self, sub_labels=None, title="Sub Dendrogram", figsize=(12, 8), **kwargs):
+        """
+        Plots the dendrogram.
+
+        Inputs:
+        - sub_labels (optional, if not defined, uses all labels): List of labels to highlight (e.g., ['cat', 'dog']).
+        - title (optional): Plot title (default: "Sub Dendrogram").
+        - figsize (optional): Figure size (default: (12, 8)).
+        - **kwargs: Additional arguments for plotting.
+
+        Outputs: None (displays plot).
+
+        Explanation: Visualizes the full dendrogram or highlights sub-labels. includes json representation of the dendrogram.
+        """
+        plot(self, sub_labels, title=title, figsize=figsize, **kwargs)
+
+    def plot_sub_dendrogram(self, sub_labels, title="Sub Dendrogram", figsize=(12, 8)):
+        """
+        Plots a sub-dendrogram for specific labels.
+
+        Inputs:
+        - sub_labels: List of labels to include (e.g., ['apple', 'banana']).
+        - title (optional): Plot title (default: "Sub Dendrogram").
+        - figsize (optional): Figure size (default: (12, 8)).
+
+        Outputs: None (displays plot).
+
+        Explanation: Renders a subset of the dendrogram based on provided labels.
+        """
+        plot_sub_dendrogram(self.dendrogram_object.Z, self.labels, sub_labels, title=title, figsize=figsize)
+
+    ## white box testing functions: ##
+
+    def white_box_testing(self, source_labels, target_labels, analyze_results=False, x_train=None, encode_images=True):
+        """
+        Performs white-box testing to find problematic images.
+
+        Inputs:
+        - source_labels: List of source labels (e.g., ['cat']).
+        - target_labels: List of target labels (e.g., ['dog']).
+        - analyze_results (optional): Whether to analyze results (default: False).
+        - x_train (optional): Training images for analysis.
+        - encode_images (optional): Whether to encode images (default: True).
+
+        Outputs: Dictionary of problematic images or analyzed results.
+
+        Explanation: Finds images that could be misclassified using edges dataframe.
+        """
+        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")
+        problematic_imgs_dict = whitebox.find_problematic_images(
+            source_labels, target_labels, self.edges_df, self.explanation_method)
+
+        if analyze_results:
+            return analyze_white_box_results(problematic_imgs_dict, x_train, encode_images)
+
+        return problematic_imgs_dict
+
+    def get_white_box_analysis(self, source_labels, target_labels, x_train=None):
+        if self.edges_df is None:
+            raise ValueError("White box testing requires edges_df. Initialize NMA with save_connections=True")
+
+
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
+            temp_path = f.name
+            self.edges_df.to_csv(temp_path, index=False)
+
+        try:
+            results = get_white_box_analysis(
+                edges_df_path=temp_path,
+                model_filename=self.model.name if hasattr(self.model, 'name') else "model",
+                dataset_str=str(self.explanation_method),
+                source_labels=source_labels,
+                target_labels=target_labels,
+                x_train=x_train
+            )
+            return results
+        finally:
+            os.unlink(temp_path)
+
+    ## adversarial detection functions: ##
+
+    def train_adversarial_detector(self, authentic_images, attacked_images):
+        """
+        Trains an adversarial detector.
+
+        Inputs:
+        - authentic_images: Array of clean images.
+        - attacked_images: Array of adversarial images.
+
+        Outputs: Trained detector model.
+
+        Explanation: Trains a logistic regression detector using dendrogram data.
+        """
+        if self.dendrogram_object is None:
+            raise ValueError("NMA must be initialized with dendrogram data for adversarial detection")
+
+        self.detector = create_logistic_regression_detector(
+            self.dendrogram_object.Z,
+            self.model,
+            authentic_images,
+            attacked_images,
+            self.labels
+        )
+        return self.detector
+
+    def detect_attack(self, image, plot_result=False):
+        """
+        Detects if an image is adversarial.
+
+        Inputs:
+        - image: Image to analyze.
+        - plot_result (optional): Whether to plot results (default: False).
+
+        Outputs: Detection result (e.g., boolean and scores).
+
+        Explanation: Uses trained detector to check for adversarial attacks.
+        """
+        if self.detector is None:
+            raise ValueError("Adversarial detector not trained. Call train_adversarial_detector first.")
+
+        return detect_adversarial_image(
+            self.model,
+            image,
+            self.detector,
+            self.dendrogram_object.Z,
+            self.labels,
+            plot_result=plot_result
+        )
+    
+    def find_lca(self, label1, label2):
+        """
+        Finds the lowest common ancestor of two labels.
+
+        Inputs:
+        - label1: First label (e.g., 'cat').
+        - label2: Second label (e.g., 'dog').
+
+        Outputs: LCA cluster or label.
+
+        Explanation: Determines the LCA in the dendrogram hierarchy.
+        """
+        lca = get_lca(label1, label2, self.dendrogram_object, self.labels)
+        return lca
+
+    def adversarial_score(self, image, top_k=5):
+        """
+        Computes adversarial score for an image.
+
+        Inputs:
+        - image: Image to score.
+        - top_k (optional): Number of top predictions (default: 5).
+
+        Outputs: Adversarial score.
+
+        Explanation: Calculates score based on predictions and dendrogram.
+        """
+        score = get_adversarial_score(image, self.model, self.dendrogram_object.Z, self.labels, top_k=top_k)
+        return score
+
+    ## query and explanation functions: ##
+
+    def query_image(self, image, top_k=5):
+        """
+        Queries the model for predictions and explanations.
+
+        Inputs:
+        - image: Image to query.
+        - top_k (optional): Number of top predictions (default: 5).
+
+        Outputs: Tuple of predictions and explanations.
+
+        Explanation: Predicts and explains using dendrogram and verbal explanation of the dendrogram.
+        """
+        if self.dendrogram_object is None:
+            raise ValueError("NMA must be initialized with dendrogram data to query images")
+        
+        if self.labels is None or len(self.labels) == 0:
+            raise ValueError("NMA must be initialized with labels to query images")
+        
+        if self.model is None:
+            raise ValueError("NMA must be initialized with a model to query images")
+
+        return query_image(image, self.model, self.labels, self.dendrogram_object, top_k=top_k)
+
+    def verbal_explanation(self, image):
+        """
+        Generates a verbal explanation for an image.
+
+        Inputs:
+        - image: Image to explain.
+
+        Outputs: Verbal explanation.
+
+        Explanation: Calls query_image and returns the explanation.
+        """
+        if self.dendrogram_object is None:
+            raise ValueError("NMA must be initialized with dendrogram data to query images")
+        
+        if self.labels is None or len(self.labels) == 0:
+            raise ValueError("NMA must be initialized with labels to query images")
+        
+        if self.model is None:
+            raise ValueError("NMA must be initialized with a model to query images")
+        
+        result = self.query_image(image)
+        if result is None:
+            return None
+        predictions, explanation = result
+        return explanation
+    
+    def change_cluster_name(self, cluster_id, new_name):
+        """
+        Renames a cluster in the dendrogram.
+
+        Inputs:
+        - cluster_id: ID of the cluster to rename.
+        - new_name: New name for the cluster.
+
+        Outputs: None (prints success or raises error).
+
+        Explanation: Updates the cluster name if valid.
+        """
+        if self.dendrogram_object is None:
+            raise ValueError("NMA must be initialized with dendrogram data to change cluster names")
+
+        result = self.dendrogram_object.rename_cluster(cluster_id, new_name)
+        if not result:
+            raise ValueError(f"Failed to rename cluster: {cluster_id}")
+        
+        print(f"Cluster {cluster_id} renamed to {new_name}")

BETTER_NMA/nma_creator.py

@@ -0,0 +1,108 @@
+import tensorflow as tf
+import pandas as pd
+from igraph import Graph
+from .utilss.enums.explanation_method import ExplanationMethod
+from .utilss.classes.preprocessing.batch_predictor import BatchPredictor
+from .utilss.classes.preprocessing.heap_processor import HeapProcessor
+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
+
+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
+        
+        graph = Graph(directed=False)
+        graph.add_vertices(labels)
+
+        edges_data = []
+        batch_images = []
+        true_labels = []
+        original_dataset_positions = [] 
+        
+        predictor = BatchPredictor(model, batch_size)
+        builder = GraphBuilder(explanation_method, infinity)
+        count = 0
+        
+        for i, image in enumerate(X):
+            source_label = y[i]
+            batch_images.append(image)
+            true_labels.append(source_label)
+            original_dataset_positions.append(i)
+            
+            if len(batch_images) == predictor.batch_size or i == len(X) - 1:
+                top_predictions_batch = predictor.get_top_predictions(
+                    batch_images, labels, top_k, threshold
+                )
+                added_labels = []
+                for j, top_predictions in enumerate(top_predictions_batch):
+                    current_label = true_labels[j]
+                    original_index = original_dataset_positions[j]
+                    seen_labels_for_image = {current_label}
+                    if len(top_predictions) == 0:
+                        print("Empty predictions for image", original_index)
+                        continue
+                    
+                    if len(top_predictions[0]) < 2:
+                        print("Malformed predictions for image", original_index)
+                        continue
+                    
+                    if top_predictions[0][2] > min_confidence:
+                        filtered_predictions = top_predictions
+
+                        if filtered_predictions[0][1] != current_label:
+                            continue
+
+                        if count < 10:
+                            # print(filtered_predictions)
+                            count = count + 1
+                        
+                        for _, pred_label, pred_prob in filtered_predictions:
+                            if pred_label not in labels:
+                                raise ValueError(
+                                    f"Prediction label '{pred_label}' not in graph labels."
+                                )
+                            # Add to seen labels set for this image
+                            seen_labels_for_image.add(pred_label)
+                            
+                            if current_label != pred_label:
+                                edge_data = builder.update_graph(
+                                    # graph, current_label, pred_label, pred_prob, i, dataset_class
+                                    graph, current_label, pred_label, pred_prob, original_index
+                                )
+                                # Only append edge_data if it's not None (not a self-loop)
+                                if edge_data is not None:
+                                    edges_data.append(edge_data)
+                                    added_labels.append(pred_label)
+                    
+                    # Now add infinity edges for all labels not seen in THIS image
+                    if explanation_method == ExplanationMethod.DISSIMILARITY.value:
+                        for label in labels:
+                            # if label != current_label:
+                            if label not in seen_labels_for_image:                                
+                                builder.add_infinity_edges(
+                                    graph, added_labels, label, current_label
+                                )
+
+                batch_images = []
+                true_labels = []
+                original_dataset_positions = []
+        
+        edges_df = None
+        if save_connections:
+            edges_df = pd.DataFrame(edges_data)
+
+        heap_processor = HeapProcessor(graph, explanation_method, labels)
+        clustering = HierarchicalClusteringBuilder(heap_processor, labels)
+        
+        z_builder = ZBuilder()
+        z = z_builder.create_z_matrix_from_tree(clustering, labels)
+        
+        dendrogram_object = Dendrogram(z)
+        dendrogram = dendrogram_object.build_tree_hierarchy(z, labels)
+        
+        return dendrogram_object, edges_df
+    except Exception as e:
+        print(f"Error while preprocessing model: {str(e)}")

BETTER_NMA/plot.py

@@ -0,0 +1,131 @@
+from re import sub
+import matplotlib.pyplot as plt
+import scipy.cluster.hierarchy as sch
+import numpy as np
+from .utilss.classes.dendrogram import Dendrogram
+
+
+def extract_sub_dendrogram(Z_full, labels, selected_labels):
+    """Extract a sub-dendrogram from the full Z matrix for only the selected labels."""
+    original_label_to_idx = {name: i for i, name in enumerate(labels)}
+
+    for label in selected_labels:
+        if label not in original_label_to_idx:
+            raise ValueError(
+                f"Label '{label}' not found in original class names")
+
+    selected_indices = [original_label_to_idx[label]
+                        for label in selected_labels]
+    Z_sub = []
+    selected_indices_set = set(selected_indices)
+    cluster_size = {i: 1 for i in range(len(selected_indices))}
+
+    new_positions = {original: new for new,
+                     original in enumerate(selected_indices)}
+    active_nodes = selected_indices.copy()
+    next_id = len(selected_indices)
+
+    for i, (left, right, height, _) in enumerate(Z_full):
+        left, right = int(left), int(right)
+        left_in_active = left in active_nodes
+        right_in_active = right in active_nodes
+
+        if left_in_active and right_in_active:
+            new_left = new_positions[left]
+            new_right = new_positions[right]
+            new_size = cluster_size.get(
+                new_left, 1) + cluster_size.get(new_right, 1)
+
+            if new_left > new_right:
+                new_left, new_right = new_right, new_left
+
+            Z_sub.append([new_left, new_right, height, new_size])
+
+            active_nodes.remove(left)
+            active_nodes.remove(right)
+            active_nodes.append(len(labels) + i)
+            new_positions[len(labels) + i] = next_id
+            cluster_size[next_id] = new_size
+            next_id += 1
+
+        elif left_in_active:
+            active_nodes.remove(left)
+            active_nodes.append(len(labels) + i)
+            new_positions[len(labels) + i] = new_positions[left]
+
+        elif right_in_active:
+            active_nodes.remove(right)
+            active_nodes.append(len(labels) + i)
+            new_positions[len(labels) + i] = new_positions[right]
+
+    if Z_sub:
+        Z_sub = np.array(Z_sub)
+        max_idx = len(selected_indices) - 1
+        for i, row in enumerate(Z_sub):
+            if row[0] > max_idx:
+                Z_sub[i, 0] = max_idx
+            if row[1] > max_idx:
+                Z_sub[i, 1] = max_idx
+            max_idx += 1
+    else:
+        Z_sub = np.empty((0, 4))
+
+    return Z_sub, selected_labels
+
+
+def plot_sub_dendrogram(Z, labels, selected_labels, title, figsize):
+
+    Z_sub, selected_labels = extract_sub_dendrogram(Z, labels, selected_labels)
+    """Plot the sub-dendrogram."""
+    if len(Z_sub) == 0:
+        raise ValueError(
+            "No clustering relationships found among selected labels.")
+
+    plt.figure(figsize=figsize)
+    sch.dendrogram(
+        Z_sub,
+        labels=selected_labels,
+        leaf_rotation=0,
+        leaf_font_size=10,
+        orientation='right',
+    )
+    plt.title(title)
+    plt.xlabel("Distance")
+    plt.ylabel("Elements")
+    plt.tight_layout()
+    plt.show()
+
+
+def plot(nma_instance, sub_labels, title, figsize, **kwargs):
+    if nma_instance.dendrogram_object.Z is None:
+        raise ValueError("No linkage matrix (z) found in NMA instance")
+
+    if sub_labels is None:
+        sub_labels = nma_instance.labels
+        
+    filtered_dendrogram_json = nma_instance.dendrogram_object.get_sub_dendrogram_formatted(
+        sub_labels)
+    print("Filtered dendrogram structure:")
+    print(filtered_dendrogram_json)
+
+    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()
+