saliencytools 0.30__tar.gz

saliencytools-0.30/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2024 six-two
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

saliencytools-0.30/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: saliencytools
+Version: 0.30
+Summary: A collection of metrics for comparing saliency maps
+Home-page: https://github.com/valevalerio/saliencytools
+Author: Valerio Bonsignori
+Author-email: Valerio Bonsignori <valerio.bonsignori@phd.unipi.it>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/valevalerio/saliencytools
+Project-URL: Issues, https://github.com/valevalerio/saliencytools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Saliency Metrics
+
+![Tests](https://github.com/valevalerio/saliencytools/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/pypi/v/saliencytools)](https://pypi.org/project/saliencytools/)
+[![Documentation Status](https://img.shields.io/website?url=https://valevalerio.github.io/saliencytools/)](https://valevalerio.github.io/saliencytools/)
+
+
+
+**Saliency Metrics** is a Python package that implements various metrics for comparing saliency maps generated by explanation methods. To ensure fair comparisons, metrics should be computed on the same saliency map and corresponding ground truth map.
+The package includes the following metrics:
+- **SSIM (Structural Similarity Index)**: A perceptual metric that quantifies the similarity between two images. It considers changes in structural information, luminance, and contrast.
+- **PSNR (Peak Signal-to-Noise Ratio)**: A metric that measures the ratio between the maximum possible power of a signal and the power of corrupting noise. It is often used to assess the quality of reconstructed images.
+- **EMD (Earth Mover's Distance)**: A metric that measures the distance between two probability distributions over a region D. It is often used in computer vision and image retrieval tasks.
+
+```tutorial.ipynb``` is an original way used to check and test the different metrics. 
+# Installation
+
+```pip install saliencytools```
+
+### This module is a work in progress and is not yet complete.
+
+# Usage
+
+```python
+from saliencytools import ssim, psnr, emd
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+
+# create a random saliency map
+saliency_map = np.random.rand(28*28).reshape(28, 28)
+# create a random ground truth map
+ground_truth_map = np.random.rand(28*28).reshape(28, 28)
+# create a random binary mask
+
+# use all the metrics to compare the saliency map with the ground truth map
+for metric in [ssim, psnr, emd]:
+    
+    print(f"{metric.__name__}: {metric(saliency_map, ground_truth_map)}")
+    
+
+```

saliencytools-0.30/README.md

@@ -0,0 +1,45 @@
+# Saliency Metrics
+
+![Tests](https://github.com/valevalerio/saliencytools/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/pypi/v/saliencytools)](https://pypi.org/project/saliencytools/)
+[![Documentation Status](https://img.shields.io/website?url=https://valevalerio.github.io/saliencytools/)](https://valevalerio.github.io/saliencytools/)
+
+
+
+**Saliency Metrics** is a Python package that implements various metrics for comparing saliency maps generated by explanation methods. To ensure fair comparisons, metrics should be computed on the same saliency map and corresponding ground truth map.
+The package includes the following metrics:
+- **SSIM (Structural Similarity Index)**: A perceptual metric that quantifies the similarity between two images. It considers changes in structural information, luminance, and contrast.
+- **PSNR (Peak Signal-to-Noise Ratio)**: A metric that measures the ratio between the maximum possible power of a signal and the power of corrupting noise. It is often used to assess the quality of reconstructed images.
+- **EMD (Earth Mover's Distance)**: A metric that measures the distance between two probability distributions over a region D. It is often used in computer vision and image retrieval tasks.
+
+```tutorial.ipynb``` is an original way used to check and test the different metrics. 
+# Installation
+
+```pip install saliencytools```
+
+### This module is a work in progress and is not yet complete.
+
+# Usage
+
+```python
+from saliencytools import ssim, psnr, emd
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+
+# create a random saliency map
+saliency_map = np.random.rand(28*28).reshape(28, 28)
+# create a random ground truth map
+ground_truth_map = np.random.rand(28*28).reshape(28, 28)
+# create a random binary mask
+
+# use all the metrics to compare the saliency map with the ground truth map
+for metric in [ssim, psnr, emd]:
+    
+    print(f"{metric.__name__}: {metric(saliency_map, ground_truth_map)}")
+    
+
+```

saliencytools-0.30/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "saliencytools"
+version = "0.30"
+authors = [
+  { name="Valerio Bonsignori", email="valerio.bonsignori@phd.unipi.it" },
+]
+description = "A collection of metrics for comparing saliency maps"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/valevalerio/saliencytools"
+Issues = "https://github.com/valevalerio/saliencytools/issues"

saliencytools-0.30/saliencytools/maskcompare.py

@@ -0,0 +1,413 @@
+"""
+This module contains functions to compare different saliency maps using various metrics.
+
+Metrics implemented:
+    - ResNet Feature Similarity (exclude the last layer, compare the extracted features)
+    - ShapGap Cosine
+    - ShapGap L2
+    - Earth Mover's Distance (EMD)
+    - Mean Absolute Error (MAE)
+    - Sign Agreement Ratio (SAR)
+    - Sign Distance
+    - Intersection over Union (IoU)
+    - Correlation Distance
+    - Mean Squared Error (MSE)
+    - Peak Signal-to-Noise Ratio (PSNR)
+    - Czekanowski Distance
+    - Jaccard Index
+    - Jaccard Distance
+    - Structural Similarity Index Measure (SSIM)
+"""
+
+import numpy as np
+import torch.nn.functional as F
+import torch
+from skimage import metrics
+from scipy.stats import wasserstein_distance
+
+# Normalization functions
+def normalize_mask(mask):
+    """
+    Normalize the mask to the range [-1, 1].
+
+    This function rescales the input saliency map to the range [-1, 1], 
+    ensuring that the values are standardized for further processing. 
+    This normalization is particularly useful when working with metrics 
+    or models that expect inputs in this range.
+
+    Parameters:
+        mask (numpy.ndarray): Input saliency map. This is a 2D or 3D array 
+                              representing the saliency values of an image.
+
+    Returns:
+        numpy.ndarray: Normalized saliency map with values in the range [-1, 1].
+    """
+    mask = mask - np.min(mask)
+    mask = mask / np.max(mask)
+    mask = 2 * mask - 1
+    return mask
+
+def normalize_mask_0_1(mask):
+    """
+    Normalize the input saliency map to the range [0, 1].
+
+    This function ensures that the values in the input saliency map are scaled 
+    to lie within the range [0, 1]. This is useful for standardizing the input 
+    data for further processing or comparison, especially when working with 
+    metrics that require normalized inputs.
+
+    Parameters:
+        mask (numpy.ndarray): Input saliency map. This is a 2D or 3D array 
+                              representing the saliency values of an image, 
+                              where higher values indicate greater importance.
+
+    Returns:
+        numpy.ndarray: Normalized saliency map with values in the range [0, 1]. 
+                       The output has the same shape as the input.
+    """
+    mask = mask - np.min(mask)
+    mask = mask / np.max(mask)
+    return mask
+
+def clip_mask(mask):
+    """
+    Clip the mask to the range [-1, 1].
+
+    This function ensures that the values in the input saliency map do not 
+    exceed the range [-1, 1]. This is useful for preventing outliers or 
+    extreme values from affecting downstream computations.
+
+    Parameters:
+        mask (numpy.ndarray): Input saliency map. This is a 2D or 3D array 
+                              representing the saliency values of an image.
+
+    Returns:
+        numpy.ndarray: Clipped saliency map with values constrained to [-1, 1].
+    """
+    return np.clip(mask, -1, 1)
+
+# Distance metrics
+def euclidean_distance(a, b):
+    """
+    Compute the Euclidean distance between two images.
+
+    The Euclidean distance measures the straight-line distance between 
+    corresponding pixels in two images. It captures the overall magnitude 
+    of differences between the two images.
+
+    Reference:
+        Commonly used in image processing and computer vision literature, also known as Frobenius norm.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Euclidean distance, representing the magnitude of differences.
+    """
+    return np.sqrt(np.sum((a - b) ** 2))
+
+def cosine_distance(a, b):
+    """
+    Compute the cosine distance between two vectors.
+
+    The cosine distance measures the angular difference between two vectors 
+    in a high-dimensional space. It is useful for comparing the orientation 
+    of two saliency maps rather than their magnitude.
+
+    Reference:
+        Commonly used in vector similarity and machine learning literature.
+        
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Cosine distance, representing the angular difference.
+    """
+    a = a.flatten()
+    b = b.flatten()
+    return 1 - np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+def emd(a, b):
+    """
+    Compute the Earth Mover's Distance (EMD) between two images.
+
+    The EMD measures the minimum cost of transforming one distribution 
+    into another. It is particularly useful for comparing saliency maps 
+    with spatial distributions of importance.
+
+    Reference:
+        Y. Rubner, C. Tomasi &  L. J. Guibas (2000) "The earth mover's distance as a metric for image retrieval."
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Earth Mover's Distance, representing the cost of transformation.
+    """
+    return wasserstein_distance(a.flatten(), b.flatten())
+
+def mean_absolute_error(a, b):
+    """
+    Compute the Mean Absolute Error (MAE) between two images.
+
+    The MAE measures the average absolute difference between corresponding 
+    pixels in two images. It captures the overall deviation in pixel values.
+
+    Reference:
+        Commonly used in regression analysis and image processing.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Mean Absolute Error, representing the average deviation.
+    """
+    return np.mean(np.abs(a - b))
+
+def sign_agreement_ratio(a, b):
+    """
+    Compute the Sign Agreement Ratio (SAR) between two images.
+
+    The SAR measures the proportion of pixels where the signs of the values 
+    in two images agree. It captures the consistency in the direction of 
+    importance between two saliency maps.
+
+    Reference:
+        A. M. Nevill, G. Atkinson (1997) "Assessing agreement between measurements recorded on a ratio scale" in sports medicine and sports science
+
+
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Sign Agreement Ratio, representing the proportion of agreement.
+    """
+    a = a.flatten()
+    b = b.flatten()
+    return 1 - np.mean(np.sign(a) == np.sign(b))
+
+def sign_distance(a, b):
+    """
+    Compute the Sign Distance between two images.
+
+    The Sign Distance measures the proportion of pixels where the signs of 
+    the values in two images differ. It is the complement of the Sign 
+    Agreement Ratio and captures the inconsistency in the direction of 
+    importance.
+
+    Reference:
+        Metric commonly used in image processing and computer vision.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Sign Distance, representing the proportion of disagreement.
+    """
+    a = a.flatten()
+    b = b.flatten()
+    return np.mean(np.sign(a) != np.sign(b))
+
+def intersection_over_union(a, b):
+    """
+    Compute the Intersection over Union (IoU) between two images.
+
+    The IoU measures the overlap between two saliency maps by comparing 
+    the intersection and union of their pixel values. It is commonly used 
+    to evaluate the similarity of binary or thresholded saliency maps.
+
+    Reference:
+        Commonly used in object detection and segmentation literature.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Intersection over Union, representing the overlap ratio.
+    """
+    a = a.flatten()
+    b = b.flatten()
+    intersection = np.sum(np.minimum(a, b))
+    union = np.sum(np.maximum(a, b))
+    return 1 - intersection / union
+
+def correlation_distance(a, b):
+    """
+    Compute the Correlation Distance between two images.
+
+    The Correlation Distance measures the linear relationship between 
+    corresponding pixel values in two images. It captures how well the 
+    variations in one image are correlated with the other.
+
+    Reference:
+        Commonly used in statistics and signal processing.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Correlation Distance, representing the inverse of correlation.
+    """
+    a = a.flatten()
+    b = b.flatten()
+    return 1 - np.corrcoef(a, b)[0, 1]
+
+def mean_squared_error(a, b):
+    """
+    Compute the Mean Squared Error (MSE) between two images.
+
+    The MSE measures the average squared difference between corresponding 
+    pixels in two images. It emphasizes larger deviations more than the 
+    Mean Absolute Error.
+
+    Reference:
+        Commonly used in regression analysis and image processing.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Mean Squared Error, representing the average squared deviation.
+    """
+    return np.mean((a - b) ** 2)
+
+def ssim(a, b):
+    """
+    Compute the Structural Similarity Index Measure (SSIM) between two images.
+
+    The SSIM evaluates the perceptual similarity between two images by 
+    considering luminance, contrast, and structure. It is widely used for 
+    assessing image quality and similarity.
+
+    Reference:
+        Wang, Z., Bovik, A. C., Sheikh, H. R., & Simoncelli, E. P. (2004). 
+        "Image quality assessment: From error visibility to structural similarity."
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: SSIM value, representing the perceptual similarity.
+    """
+    return (1 - metrics.structural_similarity(a, b, full=False,
+                                              data_range=np.maximum(a.max(), b.max()) - np.minimum(a.min(), b.min()))) / 2
+
+def psnr(a, b):
+    """
+    Compute the Peak Signal-to-Noise Ratio (PSNR) between two images.
+
+    The PSNR measures the ratio between the maximum possible pixel value 
+    and the mean squared error. It is commonly used to evaluate the quality 
+    of reconstructed images.
+
+    Reference:
+        Huynh-Thu, Q., & Ghanbari, M. (2008). 
+        "Scope of validity of PSNR in image/video quality assessment."
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: PSNR value, representing the signal-to-noise ratio.
+    """
+    return metrics.peak_signal_noise_ratio(a, b,
+                                           data_range=np.maximum(a.max(), b.max()) - np.minimum(a.min(), b.min()))
+
+def czenakowski_distance(a, b):
+    """
+    Compute the Czekanowski Distance between two images.
+
+    The Czekanowski Distance measures the dissimilarity between two images 
+    based on the ratio of their minimum and total pixel values. It is useful 
+    for comparing distributions with overlapping regions.
+
+    Reference:
+        T. SORENSEN (1948) "A method of establishing groups of equal amplitude in plant sociology based on similarity of species content and its application to analyses of the vegetation on danish commons." Biologiske Skrifter.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Czekanowski Distance, representing the dissimilarity.
+    """
+    sum_of_minimums = np.sum(np.minimum(a, b))
+    sum_of_values = np.sum(a + b)
+    if sum_of_values == 0:
+        return 0  # If both images are all zeros, they're identical
+    return 1 - (2 * sum_of_minimums) / sum_of_values
+
+def jaccard_index(a, b):
+    """
+    Compute the Jaccard Index between two images.
+
+    The Jaccard Index measures the similarity between two images by comparing 
+    the intersection and union of their pixel values. It is commonly used for 
+    evaluating binary or thresholded saliency maps.
+
+    Reference:
+        Commonly used in set theory and image segmentation literature.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Jaccard Index, representing the similarity ratio.
+    """
+    a = a.flatten()
+    b = b.flatten()
+    intersection = np.sum(np.minimum(a, b))
+    union = np.sum(np.maximum(a, b))
+    if union == 0:
+        return 0  # If both images are all zeros, they're identical
+    return intersection / union
+
+def jaccard_distance(a, b):
+    """
+    Compute the Jaccard Distance between two images.
+
+    The Jaccard Distance is the complement of the Jaccard Index and measures 
+    the dissimilarity between two images. It is useful for evaluating the 
+    differences between binary or thresholded saliency maps.
+
+    Reference:
+        Commonly used in set theory and image segmentation literature.
+
+    Parameters:
+        a (numpy.ndarray): First image.
+        b (numpy.ndarray): Second image.
+
+    Returns:
+        float: Jaccard Distance, representing the dissimilarity ratio.
+    """
+    return 1 - jaccard_index(a, b)
+
+# Assign readable names to metrics
+cosine_distance.__name__ = "$ShapGap_{Cosine}$"
+euclidean_distance.__name__ = "$ShapGap_{L2}$"
+emd.__name__ = "Earth Mover's Distance"
+mean_absolute_error.__name__ = "MAE"
+sign_agreement_ratio.__name__ = "Sign Agreement Ratio"
+sign_distance.__name__ = "Sign Distance"
+intersection_over_union.__name__ = "Intersection over Union"
+correlation_distance.__name__ = "Correlation Distance"
+mean_squared_error.__name__ = "MSE"
+ssim.__name__ = "SSIM"
+psnr.__name__ = "PSNR"
+czenakowski_distance.__name__ = "Czekanowski Distance"
+jaccard_distance.__name__ = "Jaccard Distance"
+jaccard_index.__name__ = "Jaccard Index"

saliencytools-0.30/saliencytools.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: saliencytools
+Version: 0.30
+Summary: A collection of metrics for comparing saliency maps
+Home-page: https://github.com/valevalerio/saliencytools
+Author: Valerio Bonsignori
+Author-email: Valerio Bonsignori <valerio.bonsignori@phd.unipi.it>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/valevalerio/saliencytools
+Project-URL: Issues, https://github.com/valevalerio/saliencytools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Saliency Metrics
+
+![Tests](https://github.com/valevalerio/saliencytools/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/pypi/v/saliencytools)](https://pypi.org/project/saliencytools/)
+[![Documentation Status](https://img.shields.io/website?url=https://valevalerio.github.io/saliencytools/)](https://valevalerio.github.io/saliencytools/)
+
+
+
+**Saliency Metrics** is a Python package that implements various metrics for comparing saliency maps generated by explanation methods. To ensure fair comparisons, metrics should be computed on the same saliency map and corresponding ground truth map.
+The package includes the following metrics:
+- **SSIM (Structural Similarity Index)**: A perceptual metric that quantifies the similarity between two images. It considers changes in structural information, luminance, and contrast.
+- **PSNR (Peak Signal-to-Noise Ratio)**: A metric that measures the ratio between the maximum possible power of a signal and the power of corrupting noise. It is often used to assess the quality of reconstructed images.
+- **EMD (Earth Mover's Distance)**: A metric that measures the distance between two probability distributions over a region D. It is often used in computer vision and image retrieval tasks.
+
+```tutorial.ipynb``` is an original way used to check and test the different metrics. 
+# Installation
+
+```pip install saliencytools```
+
+### This module is a work in progress and is not yet complete.
+
+# Usage
+
+```python
+from saliencytools import ssim, psnr, emd
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+
+# create a random saliency map
+saliency_map = np.random.rand(28*28).reshape(28, 28)
+# create a random ground truth map
+ground_truth_map = np.random.rand(28*28).reshape(28, 28)
+# create a random binary mask
+
+# use all the metrics to compare the saliency map with the ground truth map
+for metric in [ssim, psnr, emd]:
+    
+    print(f"{metric.__name__}: {metric(saliency_map, ground_truth_map)}")
+    
+
+```

saliencytools-0.30/saliencytools.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+saliencytools/__init__.py
+saliencytools/maskcompare.py
+saliencytools.egg-info/PKG-INFO
+saliencytools.egg-info/SOURCES.txt
+saliencytools.egg-info/dependency_links.txt
+saliencytools.egg-info/top_level.txt
+test/__init__.py
+test/test_metrics.py
+test/test_readme.py

saliencytools-0.30/saliencytools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

saliencytools-0.30/saliencytools.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+saliencytools
+test

saliencytools-0.30/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

saliencytools-0.30/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="saliencytools",
+    version="0.1.0",
+    author="Valerio Bonsignori",
+    author_email="valerio.bonsignori@phd.unipi.it",
+    description="A collection of metrics to compare saliency maps, validated using KNN-like classifiers on MNIST.",
+    long_description= open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/valevalerio/saliencytools",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.10",
+    install_requires=[
+        "numpy==1.24.4",
+        "pandas==1.5.3",
+        "matplotlib==3.7.5",
+        "seaborn==0.13.2",
+        "scikit-learn==1.3.2",
+        "scikit-multilearn==0.2.0",
+        "scipy==1.10.1",
+        "torch",
+        "sklearn-image"
+    ],
+)

saliencytools-0.30/test/test_metrics.py

@@ -0,0 +1,61 @@
+""" This Module is used to check the coherency of the metrics implemented in the project."""
+
+from saliencytools import (
+    normalize_mask_0_1,
+    clip_mask,
+    euclidean_distance,
+    cosine_distance,
+    emd,
+    mean_absolute_error,
+    sign_agreement_ratio,
+    sign_distance,
+    intersection_over_union,
+    correlation_distance,
+    mean_squared_error,
+    ssim,
+    psnr,
+    czenakowski_distance,
+    jaccard_distance)
+import numpy as np
+def test_metrics():
+    
+    test_map_1 = np.random.rand(28*28).reshape(28, 28)
+    test_map_2 = np.random.rand(28*28).reshape(28, 28)
+    
+    # Clip the maps
+    test_map_1 = clip_mask(test_map_1)
+    test_map_2 = clip_mask(test_map_2)
+    # Normalize the maps
+    test_map_1 = normalize_mask_0_1(test_map_1)
+    test_map_2 = normalize_mask_0_1(test_map_2)
+
+    # Check if the maps are not empty
+    assert test_map_1.size > 0, "test_map_1 is empty"
+    assert test_map_2.size > 0, "test_map_2 is empty"
+    
+    for metric in [
+        euclidean_distance,
+        cosine_distance,
+        emd,
+        mean_absolute_error,
+        sign_agreement_ratio,
+        sign_distance,
+        intersection_over_union,
+        correlation_distance,
+        mean_squared_error,
+        ssim,
+        psnr,
+        czenakowski_distance,
+        jaccard_distance
+    ]:
+        # Check if the metric is symmetric
+        assert metric(test_map_1, test_map_2) == metric(test_map_2, test_map_1), f"{metric.__name__} is not symmetric"
+        # Check if the metric is non-negative
+        assert metric(test_map_1, test_map_2) >= 0, f"{metric.__name__} is negative"
+        # Check if the metric is zero when both maps are identical
+        if metric.__name__ not in ["ssim", "psnr"]:
+            # Skip ssim and psnr for this test
+            # as they are not zero when the maps are identical
+            continue
+        # Check if the metric is zero when both maps are identical
+        assert np.allclose(metric(test_map_1, test_map_1), 0), f"{metric.__name__} is not zero when maps are identical"

saliencytools-0.30/test/test_readme.py

@@ -0,0 +1,19 @@
+from saliencytools import ssim, psnr, emd
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def test_readme():
+    """
+    This function is used to test the README file
+    by running the example code in the README file
+    """
+    # create a random saliency map
+    saliency_map = np.random.rand(28*28).reshape(28, 28)
+    # create a random ground truth map
+    ground_truth_map = np.random.rand(28*28).reshape(28, 28)
+
+    # use all the metrics to compare the saliency map with the ground truth map
+    for metric in [ssim, psnr, emd]:
+        f"{metric.__name__}: {metric(saliency_map, ground_truth_map)}"