Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics-1.9.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics-1.9.0.dist-info/METADATA

@@ -0,0 +1,582 @@
+Metadata-Version: 2.4
+Name: torchmetrics
+Version: 1.9.0
+Summary: PyTorch native Metrics
+Home-page: https://github.com/Lightning-AI/torchmetrics
+Download-URL: https://github.com/Lightning-AI/torchmetrics/archive/master.zip
+Author: Lightning-AI et al.
+Author-email: name@pytorchlightning.ai
+License: Apache-2.0
+Project-URL: Bug Tracker, https://github.com/Lightning-AI/torchmetrics/issues
+Project-URL: Documentation, https://torchmetrics.rtfd.io/en/latest/
+Project-URL: Source Code, https://github.com/Lightning-AI/torchmetrics
+Keywords: deep learning,machine learning,pytorch,metrics,AI
+Classifier: Environment :: Console
+Classifier: Natural Language :: English
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>1.20.0
+Requires-Dist: packaging>17.1
+Requires-Dist: torch>=2.0.0
+Requires-Dist: lightning-utilities>=0.15.3
+Provides-Extra: audio
+Requires-Dist: requests>=2.22.0; extra == "audio"
+Requires-Dist: onnxruntime>=1.12.0; extra == "audio"
+Requires-Dist: gammatone>=1.0.0; extra == "audio"
+Requires-Dist: pesq>=0.0.4; extra == "audio"
+Requires-Dist: pystoi>=0.4.0; extra == "audio"
+Requires-Dist: librosa>=0.10.0; extra == "audio"
+Requires-Dist: torchaudio>=2.0.1; extra == "audio"
+Provides-Extra: clustering
+Requires-Dist: torch_linear_assignment>=0.0.2; extra == "clustering"
+Provides-Extra: debug
+Provides-Extra: detection
+Requires-Dist: pycocotools>2.0.0; extra == "detection"
+Requires-Dist: torchvision>=0.15.1; extra == "detection"
+Provides-Extra: image
+Requires-Dist: torch-fidelity<=0.4.0; extra == "image"
+Requires-Dist: torchvision>=0.15.1; extra == "image"
+Requires-Dist: scipy>1.0.0; extra == "image"
+Provides-Extra: integrate
+Provides-Extra: multimodal
+Requires-Dist: timm>=0.9.0; extra == "multimodal"
+Requires-Dist: transformers>=4.43.0; extra == "multimodal"
+Requires-Dist: einops>=0.7.0; extra == "multimodal"
+Requires-Dist: piq<=0.8.0; extra == "multimodal"
+Provides-Extra: text
+Requires-Dist: tqdm<4.68.0; extra == "text"
+Requires-Dist: nltk>3.8.1; extra == "text"
+Requires-Dist: ipadic>=1.0.0; extra == "text"
+Requires-Dist: mecab-python3>=1.0.6; extra == "text"
+Requires-Dist: transformers>=4.43.0; extra == "text"
+Requires-Dist: regex>=2021.9.24; extra == "text"
+Requires-Dist: sentencepiece>=0.2.0; extra == "text"
+Provides-Extra: typing
+Requires-Dist: types-six; extra == "typing"
+Requires-Dist: mypy==1.17.1; extra == "typing"
+Requires-Dist: types-requests; extra == "typing"
+Requires-Dist: types-tabulate; extra == "typing"
+Requires-Dist: types-setuptools; extra == "typing"
+Requires-Dist: types-emoji; extra == "typing"
+Requires-Dist: torch==2.8.0; extra == "typing"
+Requires-Dist: types-PyYAML; extra == "typing"
+Requires-Dist: types-protobuf; extra == "typing"
+Provides-Extra: video
+Requires-Dist: vmaf-torch>=1.1.0; extra == "video"
+Requires-Dist: einops>=0.7.0; extra == "video"
+Provides-Extra: visual
+Requires-Dist: matplotlib>=3.6.0; extra == "visual"
+Requires-Dist: SciencePlots>=2.0.0; extra == "visual"
+Provides-Extra: all
+Requires-Dist: requests>=2.22.0; extra == "all"
+Requires-Dist: onnxruntime>=1.12.0; extra == "all"
+Requires-Dist: gammatone>=1.0.0; extra == "all"
+Requires-Dist: pesq>=0.0.4; extra == "all"
+Requires-Dist: pystoi>=0.4.0; extra == "all"
+Requires-Dist: librosa>=0.10.0; extra == "all"
+Requires-Dist: torchaudio>=2.0.1; extra == "all"
+Requires-Dist: torch_linear_assignment>=0.0.2; extra == "all"
+Requires-Dist: pycocotools>2.0.0; extra == "all"
+Requires-Dist: torchvision>=0.15.1; extra == "all"
+Requires-Dist: torch-fidelity<=0.4.0; extra == "all"
+Requires-Dist: torchvision>=0.15.1; extra == "all"
+Requires-Dist: scipy>1.0.0; extra == "all"
+Requires-Dist: timm>=0.9.0; extra == "all"
+Requires-Dist: transformers>=4.43.0; extra == "all"
+Requires-Dist: einops>=0.7.0; extra == "all"
+Requires-Dist: piq<=0.8.0; extra == "all"
+Requires-Dist: tqdm<4.68.0; extra == "all"
+Requires-Dist: nltk>3.8.1; extra == "all"
+Requires-Dist: ipadic>=1.0.0; extra == "all"
+Requires-Dist: mecab-python3>=1.0.6; extra == "all"
+Requires-Dist: transformers>=4.43.0; extra == "all"
+Requires-Dist: regex>=2021.9.24; extra == "all"
+Requires-Dist: sentencepiece>=0.2.0; extra == "all"
+Requires-Dist: types-six; extra == "all"
+Requires-Dist: mypy==1.17.1; extra == "all"
+Requires-Dist: types-requests; extra == "all"
+Requires-Dist: types-tabulate; extra == "all"
+Requires-Dist: types-setuptools; extra == "all"
+Requires-Dist: types-emoji; extra == "all"
+Requires-Dist: torch==2.8.0; extra == "all"
+Requires-Dist: types-PyYAML; extra == "all"
+Requires-Dist: types-protobuf; extra == "all"
+Requires-Dist: vmaf-torch>=1.1.0; extra == "all"
+Requires-Dist: einops>=0.7.0; extra == "all"
+Requires-Dist: matplotlib>=3.6.0; extra == "all"
+Requires-Dist: SciencePlots>=2.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: requests>=2.22.0; extra == "dev"
+Requires-Dist: onnxruntime>=1.12.0; extra == "dev"
+Requires-Dist: gammatone>=1.0.0; extra == "dev"
+Requires-Dist: pesq>=0.0.4; extra == "dev"
+Requires-Dist: pystoi>=0.4.0; extra == "dev"
+Requires-Dist: librosa>=0.10.0; extra == "dev"
+Requires-Dist: torchaudio>=2.0.1; extra == "dev"
+Requires-Dist: torch_linear_assignment>=0.0.2; extra == "dev"
+Requires-Dist: pycocotools>2.0.0; extra == "dev"
+Requires-Dist: torchvision>=0.15.1; extra == "dev"
+Requires-Dist: torch-fidelity<=0.4.0; extra == "dev"
+Requires-Dist: torchvision>=0.15.1; extra == "dev"
+Requires-Dist: scipy>1.0.0; extra == "dev"
+Requires-Dist: timm>=0.9.0; extra == "dev"
+Requires-Dist: transformers>=4.43.0; extra == "dev"
+Requires-Dist: einops>=0.7.0; extra == "dev"
+Requires-Dist: piq<=0.8.0; extra == "dev"
+Requires-Dist: tqdm<4.68.0; extra == "dev"
+Requires-Dist: nltk>3.8.1; extra == "dev"
+Requires-Dist: ipadic>=1.0.0; extra == "dev"
+Requires-Dist: mecab-python3>=1.0.6; extra == "dev"
+Requires-Dist: transformers>=4.43.0; extra == "dev"
+Requires-Dist: regex>=2021.9.24; extra == "dev"
+Requires-Dist: sentencepiece>=0.2.0; extra == "dev"
+Requires-Dist: types-six; extra == "dev"
+Requires-Dist: mypy==1.17.1; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: types-tabulate; extra == "dev"
+Requires-Dist: types-setuptools; extra == "dev"
+Requires-Dist: types-emoji; extra == "dev"
+Requires-Dist: torch==2.8.0; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+Requires-Dist: types-protobuf; extra == "dev"
+Requires-Dist: vmaf-torch>=1.1.0; extra == "dev"
+Requires-Dist: einops>=0.7.0; extra == "dev"
+Requires-Dist: matplotlib>=3.6.0; extra == "dev"
+Requires-Dist: SciencePlots>=2.0.0; extra == "dev"
+Requires-Dist: pytorch-msssim==1.0.0; extra == "dev"
+Requires-Dist: sewar>=0.4.4; extra == "dev"
+Requires-Dist: setuptools<82.0.0; extra == "dev"
+Requires-Dist: scikit-image>=0.19.0; extra == "dev"
+Requires-Dist: dists-pytorch==0.1; extra == "dev"
+Requires-Dist: rouge-score>0.1.0; extra == "dev"
+Requires-Dist: netcal>1.0.0; extra == "dev"
+Requires-Dist: pandas>1.4.0; extra == "dev"
+Requires-Dist: numpy<2.4.0; extra == "dev"
+Requires-Dist: torch_complex<0.5.0; extra == "dev"
+Requires-Dist: permetrics==2.0.0; extra == "dev"
+Requires-Dist: jiwer>=2.3.0; extra == "dev"
+Requires-Dist: aeon>=1.0.0; python_version > "3.10" and extra == "dev"
+Requires-Dist: mir-eval>=0.6; extra == "dev"
+Requires-Dist: huggingface-hub<0.35; extra == "dev"
+Requires-Dist: faster-coco-eval>=1.6.3; extra == "dev"
+Requires-Dist: mecab-ko-dic>=1.0.0; python_version < "3.12" and extra == "dev"
+Requires-Dist: monai==1.4.0; extra == "dev"
+Requires-Dist: mecab-ko<1.1.0,>=1.0.0; python_version < "3.12" and extra == "dev"
+Requires-Dist: bert_score==0.3.13; extra == "dev"
+Requires-Dist: sacrebleu>=2.3.0; extra == "dev"
+Requires-Dist: scipy>1.0.0; extra == "dev"
+Requires-Dist: lpips<=0.1.4; extra == "dev"
+Requires-Dist: dython==0.7.9; extra == "dev"
+Requires-Dist: properscoring==0.1; extra == "dev"
+Requires-Dist: fast-bss-eval>=0.1.0; extra == "dev"
+Requires-Dist: PyTDC==0.4.1; (platform_system == "Windows" and python_version < "3.12") and extra == "dev"
+Requires-Dist: fairlearn; extra == "dev"
+Requires-Dist: kornia>=0.6.7; extra == "dev"
+Requires-Dist: statsmodels>0.13.5; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<div align="center">
+
+<img src="https://github.com/Lightning-AI/torchmetrics/raw/v1.9.0/docs/source/_static/images/logo.png" width="400px">
+
+**Machine learning metrics for distributed, scalable PyTorch applications.**
+
+______________________________________________________________________
+
+<p align="center">
+  <a href="#what-is-torchmetrics">What is Torchmetrics</a> •
+  <a href="#implementing-your-own-module-metric">Implementing a metric</a> •
+  <a href="#build-in-metrics">Built-in metrics</a> •
+  <a href="https://lightning.ai/docs/torchmetrics/stable/">Docs</a> •
+  <a href="#community">Community</a> •
+  <a href="#license">License</a>
+</p>
+
+______________________________________________________________________
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/torchmetrics)](https://pypi.org/project/torchmetrics/)
+[![PyPI Status](https://badge.fury.io/py/torchmetrics.svg)](https://badge.fury.io/py/torchmetrics)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/torchmetrics)
+](https://pepy.tech/project/torchmetrics)
+[![Conda](https://img.shields.io/conda/v/conda-forge/torchmetrics?label=conda&color=success)](https://anaconda.org/conda-forge/torchmetrics)
+[![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Lightning-AI/torchmetrics/blob/master/LICENSE)
+
+[![CI testing | CPU](https://github.com/Lightning-AI/torchmetrics/actions/workflows/ci-tests.yml/badge.svg?event=push)](https://github.com/Lightning-AI/torchmetrics/actions/workflows/ci-tests.yml)
+[![Build Status](https://dev.azure.com/Lightning-AI/Metrics/_apis/build/status%2FTM.unittests?branchName=refs%2Ftags%2Fv1.9.0)](https://dev.azure.com/Lightning-AI/Metrics/_build/latest?definitionId=2&branchName=refs%2Ftags%2Fv1.9.0)
+[![codecov](https://codecov.io/gh/Lightning-AI/torchmetrics/release/v1.9.0/graph/badge.svg?token=NER6LPI3HS)](https://codecov.io/gh/Lightning-AI/torchmetrics)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/Lightning-AI/torchmetrics/master.svg)](https://results.pre-commit.ci/latest/github/Lightning-AI/torchmetrics/master)
+
+[![Documentation Status](https://readthedocs.org/projects/torchmetrics/badge/?version=latest)](https://torchmetrics.readthedocs.io/en/latest/?badge=latest)
+[![Discord](https://img.shields.io/discord/1077906959069626439?style=plastic)](https://discord.gg/VptPCZkGNa)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5844769.svg)](https://doi.org/10.5281/zenodo.5844769)
+[![JOSS status](https://joss.theoj.org/papers/561d9bb59b400158bc8204e2639dca43/status.svg)](https://joss.theoj.org/papers/561d9bb59b400158bc8204e2639dca43)
+
+______________________________________________________________________
+
+</div>
+
+# Looking for GPUs?
+
+Over 340,000 developers use [Lightning Cloud](https://lightning.ai/?utm_source=tm_readme&utm_medium=referral&utm_campaign=tm_readme) - purpose-built for PyTorch and PyTorch Lightning.
+
+- [GPUs](https://lightning.ai/pricing?utm_source=tm_readme&utm_medium=referral&utm_campaign=tm_readme) from $0.19.
+- [Clusters](https://lightning.ai/clusters?utm_source=tm_readme&utm_medium=referral&utm_campaign=tm_readme): frontier-grade training/inference clusters.
+- [AI Studio (vibe train)](https://lightning.ai/studios?utm_source=tm_readme&utm_medium=referral&utm_campaign=tm_readme): workspaces where AI helps you debug, tune and vibe train.
+- [AI Studio (vibe deploy)](https://lightning.ai/studios?utm_source=tm_readme&utm_medium=referral&utm_campaign=tm_readme): workspaces where AI helps you optimize, and deploy models.
+- [Notebooks](https://lightning.ai/notebooks?utm_source=tm_readme&utm_medium=referral&utm_campaign=tm_readme): Persistent GPU workspaces where AI helps you code and analyze.
+- [Inference](https://lightning.ai/deploy?utm_source=tm_readme&utm_medium=referral&utm_campaign=tm_readme): Deploy models as inference APIs.
+
+# Installation
+
+Simple installation from PyPI
+
+```bash
+pip install torchmetrics
+```
+
+<details>
+  <summary>Other installations</summary>
+
+Install using conda
+
+```bash
+conda install -c conda-forge torchmetrics
+```
+
+Install using uv
+
+```bash
+uv add torchmetrics
+```
+
+Pip from source
+
+```bash
+# with git
+pip install git+https://github.com/Lightning-AI/torchmetrics.git@release/stable
+```
+
+Pip from archive
+
+```bash
+pip install https://github.com/Lightning-AI/torchmetrics/archive/refs/heads/release/stable.zip
+```
+
+Extra dependencies for specialized metrics:
+
+```bash
+pip install torchmetrics[audio]
+pip install torchmetrics[image]
+pip install torchmetrics[text]
+pip install torchmetrics[all]  # install all of the above
+```
+
+Install latest developer version
+
+```bash
+pip install https://github.com/Lightning-AI/torchmetrics/archive/master.zip
+```
+
+</details>
+
+______________________________________________________________________
+
+# What is TorchMetrics
+
+TorchMetrics is a collection of 100+ PyTorch metrics implementations and an easy-to-use API to create custom metrics. It offers:
+
+- A standardized interface to increase reproducibility
+- Reduces boilerplate
+- Automatic accumulation over batches
+- Metrics optimized for distributed-training
+- Automatic synchronization between multiple devices
+
+You can use TorchMetrics with any PyTorch model or with [PyTorch Lightning](https://lightning.ai/docs/pytorch/stable/) to enjoy additional features such as:
+
+- Module metrics are automatically placed on the correct device.
+- Native support for logging metrics in Lightning to reduce even more boilerplate.
+
+# Using TorchMetrics
+
+### Module metrics
+
+The [module-based metrics](https://lightning.ai/docs/torchmetrics/stable/references/metric.html) contain internal metric states (similar to the parameters of the PyTorch module) that automate accumulation and synchronization across devices!
+
+- Automatic accumulation over multiple batches
+- Automatic synchronization between multiple devices
+- Metric arithmetic
+
+**This can be run on CPU, single GPU or multi-GPUs!**
+
+For the single GPU/CPU case:
+
+```python
+import torch
+
+# import our library
+import torchmetrics
+
+# initialize metric
+metric = torchmetrics.classification.Accuracy(task="multiclass", num_classes=5)
+
+# move the metric to device you want computations to take place
+device = "cuda" if torch.cuda.is_available() else "cpu"
+metric.to(device)
+
+n_batches = 10
+for i in range(n_batches):
+    # simulate a classification problem
+    preds = torch.randn(10, 5).softmax(dim=-1).to(device)
+    target = torch.randint(5, (10,)).to(device)
+
+    # metric on current batch
+    acc = metric(preds, target)
+    print(f"Accuracy on batch {i}: {acc}")
+
+# metric on all batches using custom accumulation
+acc = metric.compute()
+print(f"Accuracy on all data: {acc}")
+```
+
+Module metric usage remains the same when using multiple GPUs or multiple nodes.
+
+<details>
+  <summary>Example using DDP</summary>
+
+<!--phmdoctest-mark.skip-->
+
+```python
+import os
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch import nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+import torchmetrics
+
+
+def metric_ddp(rank, world_size):
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "12355"
+
+    # create default process group
+    dist.init_process_group("gloo", rank=rank, world_size=world_size)
+
+    # initialize model
+    metric = torchmetrics.classification.Accuracy(task="multiclass", num_classes=5)
+
+    # define a model and append your metric to it
+    # this allows metric states to be placed on correct accelerators when
+    # .to(device) is called on the model
+    model = nn.Linear(10, 10)
+    model.metric = metric
+    model = model.to(rank)
+
+    # initialize DDP
+    model = DDP(model, device_ids=[rank])
+
+    n_epochs = 5
+    # this shows iteration over multiple training epochs
+    for n in range(n_epochs):
+        # this will be replaced by a DataLoader with a DistributedSampler
+        n_batches = 10
+        for i in range(n_batches):
+            # simulate a classification problem
+            preds = torch.randn(10, 5).softmax(dim=-1)
+            target = torch.randint(5, (10,))
+
+            # metric on current batch
+            acc = metric(preds, target)
+            if rank == 0:  # print only for rank 0
+                print(f"Accuracy on batch {i}: {acc}")
+
+        # metric on all batches and all accelerators using custom accumulation
+        # accuracy is same across both accelerators
+        acc = metric.compute()
+        print(f"Accuracy on all data: {acc}, accelerator rank: {rank}")
+
+        # Resetting internal state such that metric ready for new data
+        metric.reset()
+
+    # cleanup
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    world_size = 2  # number of gpus to parallelize over
+    mp.spawn(metric_ddp, args=(world_size,), nprocs=world_size, join=True)
+```
+
+</details>
+
+### Implementing your own Module metric
+
+Implementing your own metric is as easy as subclassing an [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html). Simply, subclass `torchmetrics.Metric`
+and just implement the `update` and `compute` methods:
+
+```python
+import torch
+from torchmetrics import Metric
+
+
+class MyAccuracy(Metric):
+    def __init__(self):
+        # remember to call super
+        super().__init__()
+        # call `self.add_state`for every internal state that is needed for the metrics computations
+        # dist_reduce_fx indicates the function that should be used to reduce
+        # state from multiple processes
+        self.add_state("correct", default=torch.tensor(0), dist_reduce_fx="sum")
+        self.add_state("total", default=torch.tensor(0), dist_reduce_fx="sum")
+
+    def update(self, preds: torch.Tensor, target: torch.Tensor) -> None:
+        # extract predicted class index for computing accuracy
+        preds = preds.argmax(dim=-1)
+        assert preds.shape == target.shape
+        # update metric states
+        self.correct += torch.sum(preds == target)
+        self.total += target.numel()
+
+    def compute(self) -> torch.Tensor:
+        # compute final result
+        return self.correct.float() / self.total
+
+
+my_metric = MyAccuracy()
+preds = torch.randn(10, 5).softmax(dim=-1)
+target = torch.randint(5, (10,))
+
+print(my_metric(preds, target))
+```
+
+### Functional metrics
+
+Similar to [`torch.nn`](https://pytorch.org/docs/stable/nn.html), most metrics have both a [module-based](https://lightning.ai/docs/torchmetrics/stable/references/metric.html) and functional version.
+The functional versions are simple python functions that as input take [torch.tensors](https://pytorch.org/docs/stable/tensors.html) and return the corresponding metric as a [torch.tensor](https://pytorch.org/docs/stable/tensors.html).
+
+```python
+import torch
+
+# import our library
+import torchmetrics
+
+# simulate a classification problem
+preds = torch.randn(10, 5).softmax(dim=-1)
+target = torch.randint(5, (10,))
+
+acc = torchmetrics.functional.classification.multiclass_accuracy(
+    preds, target, num_classes=5
+)
+```
+
+### Covered domains and example metrics
+
+In total TorchMetrics contains [100+ metrics](https://lightning.ai/docs/torchmetrics/stable/all-metrics.html), which
+covers the following domains:
+
+- Audio
+- Classification
+- Detection
+- Information Retrieval
+- Image
+- Multimodal (Image-Text-3D Talking Heads)
+- Nominal
+- Regression
+- Segmentation
+- Text
+
+Each domain may require some additional dependencies which can be installed with `pip install torchmetrics[audio]`,
+`pip install torchmetrics['image']` etc.
+
+### Additional features
+
+#### Plotting
+
+Visualization of metrics can be important to help understand what is going on with your machine learning algorithms.
+Torchmetrics have built-in plotting support (install dependencies with `pip install torchmetrics[visual]`) for nearly
+all modular metrics through the `.plot` method. Simply call the method to get a simple visualization of any metric!
+
+```python
+import torch
+from torchmetrics.classification import MulticlassAccuracy, MulticlassConfusionMatrix
+
+num_classes = 3
+
+# this will generate two distributions that comes more similar as iterations increase
+w = torch.randn(num_classes)
+target = lambda it: torch.multinomial((it * w).softmax(dim=-1), 100, replacement=True)
+preds = lambda it: torch.multinomial((it * w).softmax(dim=-1), 100, replacement=True)
+
+acc = MulticlassAccuracy(num_classes=num_classes, average="micro")
+acc_per_class = MulticlassAccuracy(num_classes=num_classes, average=None)
+confmat = MulticlassConfusionMatrix(num_classes=num_classes)
+
+# plot single value
+for i in range(5):
+    acc_per_class.update(preds(i), target(i))
+    confmat.update(preds(i), target(i))
+fig1, ax1 = acc_per_class.plot()
+fig2, ax2 = confmat.plot()
+
+# plot multiple values
+values = []
+for i in range(10):
+    values.append(acc(preds(i), target(i)))
+fig3, ax3 = acc.plot(values)
+```
+
+<p align="center">
+  <img src="https://github.com/Lightning-AI/torchmetrics/raw/v1.9.0/docs/source/_static/images/plot_example.png" width="1000">
+</p>
+
+For examples of plotting different metrics try running [this example file](_samples/plotting.py).
+
+# Contribute!
+
+The lightning + TorchMetrics team is hard at work adding even more metrics.
+But we're looking for incredible contributors like you to submit new metrics
+and improve existing ones!
+
+Join our [Discord](https://discord.com/invite/tfXFetEZxv) to get help with becoming a contributor!
+
+# Community
+
+For help or questions, join our huge community on [Discord](https://discord.com/invite/tfXFetEZxv)!
+
+# Citation
+
+We’re excited to continue the strong legacy of open source software and have been inspired
+over the years by Caffe, Theano, Keras, PyTorch, torchbearer, ignite, sklearn and fast.ai.
+
+If you want to cite this framework feel free to use GitHub's built-in citation option to generate a bibtex or APA-Style citation based on [this file](https://github.com/Lightning-AI/torchmetrics/blob/master/CITATION.cff) (but only if you loved it 😊).
+
+# License
+
+Please observe the Apache 2.0 license that is listed in this repository.
+In addition, the Lightning framework is Patent Pending.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics-1.9.0.dist-info/RECORD

@@ -0,0 +1,709 @@
+torchmetrics-1.9.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+torchmetrics-1.9.0.dist-info/METADATA,sha256=6aaxD25cq-5RUK_DDtcP3RTlVrG4VpeaM0HSy6Ibqt0,23134
+torchmetrics-1.9.0.dist-info/RECORD,,
+torchmetrics-1.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+torchmetrics-1.9.0.dist-info/licenses/LICENSE,sha256=-jH0M_W0vB-3MPucZ4-QGC2Tv3a22Yuk0A9ARUrIuDI,11352
+torchmetrics-1.9.0.dist-info/top_level.txt,sha256=wUt7Alce9yBXuCXPU2Mcfh3_6ZjoYejoj2silrPGA_Q,13
+torchmetrics/__about__.py,sha256=D5zucYwCJrFMOc_8wbvI8p-r8XRT-j6kVaOvw_dNfnU,1239
+torchmetrics/__init__.py,sha256=NinAv0FcLhc4rO-8cH_FXB-0cEqvI38uZL0v6sYk6Ls,9490
+torchmetrics/__pycache__/__about__.cpython-310.pyc,,
+torchmetrics/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/__pycache__/aggregation.cpython-310.pyc,,
+torchmetrics/__pycache__/collections.cpython-310.pyc,,
+torchmetrics/__pycache__/metric.cpython-310.pyc,,
+torchmetrics/aggregation.py,sha256=0b56QtlPggVi4YC0oPeLlYvFOD1Q7IWKhRtKIBLRqII,28384
+torchmetrics/audio/__init__.py,sha256=yRvq2xMGIOveZSWYGqhRF01oLpvWej_iyc4vn6UQqew,2536
+torchmetrics/audio/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/dnsmos.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/nisqa.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/pesq.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/pit.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/sdr.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/snr.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/srmr.cpython-310.pyc,,
+torchmetrics/audio/__pycache__/stoi.cpython-310.pyc,,
+torchmetrics/audio/_deprecated.py,sha256=-_Q_my6O20Itu7ISoyKqZz3NmN6xMk4uTH8s48BV4Ag,4065
+torchmetrics/audio/dnsmos.py,sha256=DVBuN07qox7KNNDCZ3my0PjL2hZtkIYfqux5prjZgI4,8057
+torchmetrics/audio/nisqa.py,sha256=_m9EeZQfEd0MNwlwZACOOQAuSScpgoERrtieFuyzAdk,6027
+torchmetrics/audio/pesq.py,sha256=l5Y0ClQhqnWiKkmBD0W9fwt80qE6QsO62USvZhPn1is,7348
+torchmetrics/audio/pit.py,sha256=TxGn-jDkK3yVavjnRTxCKMWVovQzoijiZKNSkIfQpbo,6914
+torchmetrics/audio/sdr.py,sha256=aQzlxGiONWBfNWxzAgLLmkrL9vjDh--2an2-SdETbYg,15295
+torchmetrics/audio/snr.py,sha256=FJQKwuHUoB8Q--mlrDKL3sH6kdpZTlkupP60UpQsvQU,12701
+torchmetrics/audio/srmr.py,sha256=HxYPY1sh8b26iZw5jc1BnHwa_LRD5el58Ogec0HjY9U,7378
+torchmetrics/audio/stoi.py,sha256=ZtaXNTieNiDuhfntrPP_1Mu1TxEBr9hAxC0vz1RyJ34,6428
+torchmetrics/classification/__init__.py,sha256=DWUA3NXdeh20ZyFuLGQ6QKcoGM1aZfT6XKPqwhhkW9Q,7467
+torchmetrics/classification/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/accuracy.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/auroc.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/average_precision.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/base.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/calibration_error.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/cohen_kappa.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/confusion_matrix.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/eer.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/exact_match.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/f_beta.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/group_fairness.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/hamming.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/hinge.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/jaccard.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/logauc.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/matthews_corrcoef.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/negative_predictive_value.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/precision_fixed_recall.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/precision_recall.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/precision_recall_curve.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/ranking.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/recall_fixed_precision.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/roc.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/sensitivity_specificity.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/specificity.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/specificity_sensitivity.cpython-310.pyc,,
+torchmetrics/classification/__pycache__/stat_scores.cpython-310.pyc,,
+torchmetrics/classification/accuracy.py,sha256=li5d2sLrZMU11EOJxwbf0k5CVf4EbzykR1qhEOqK44Q,23408
+torchmetrics/classification/auroc.py,sha256=SAb3TdBVCWpoZ2ki2ftiL2rqK5S08Fntej2Tc1lTrG0,25595
+torchmetrics/classification/average_precision.py,sha256=OxolA2NDz6K3C_LuL5_cexeVvOU_5pYJgBhpqYF3dQ0,25457
+torchmetrics/classification/base.py,sha256=V5wu8vUqgJ23upaI4alsL7019gkL9H3k4A1-oXG4FXY,1234
+torchmetrics/classification/calibration_error.py,sha256=ZJgJcbtCMPgE2jgwrV6Kl-vlyG78JJfTMa49rhO9tLE,17288
+torchmetrics/classification/cohen_kappa.py,sha256=UVTRv8x9_s4-Ixnxl7qf8yWzRZGKyK5JctcHTz5LuT0,13717
+torchmetrics/classification/confusion_matrix.py,sha256=ulifUwFRmr45Gw-K-grd_nliQYUwKtJrx2Dt-e9oowg,23841
+torchmetrics/classification/eer.py,sha256=c_BFrYkbdRu2cuJftio_r4NP2u4CR187vp1k4cWTG-A,21210
+torchmetrics/classification/exact_match.py,sha256=i1WQDaRYUYzxaiBeJEAtcXSJVEPjr8rELrDtEcMhKI4,20293
+torchmetrics/classification/f_beta.py,sha256=1YxmohjAAwMXybbf2p7tncdseJthu9XRbCrQMkWsjss,54228
+torchmetrics/classification/group_fairness.py,sha256=gaTZRXdEdpFwwOpvbpSo4zr0nm-S1nd2CiYWZoZrs1I,13784
+torchmetrics/classification/hamming.py,sha256=LNEJxKWB_jr4QCkACseoY42mnFlrYSNidHsMMuCCrpA,24081
+torchmetrics/classification/hinge.py,sha256=djewxadp9uubjuXIX-zpuHgLmcettQUwHM3k9eG0UEo,15828
+torchmetrics/classification/jaccard.py,sha256=KoQZwZ6plXFqtrdGl3gTpJNv19g2Wo471tMA1x3aexg,20552
+torchmetrics/classification/logauc.py,sha256=syZ1mL2VEWanxVEGQx4bj5kCprZjFLzXLVRhpxFl8KY,23446
+torchmetrics/classification/matthews_corrcoef.py,sha256=SucLKvwnTJIQCbBhV8lTrUWTowzxfNCz-QOrK-GVA1U,17086
+torchmetrics/classification/negative_predictive_value.py,sha256=HA6enJuGNAtlFLnDug9pOUgjGXLGbuwcD4mq8VxNDSo,24587
+torchmetrics/classification/precision_fixed_recall.py,sha256=pRTECzSJbsoDTHkPAY8YICc9wM2pw7RMmNEC0sw9kqo,25300
+torchmetrics/classification/precision_recall.py,sha256=gbPlpSJTiV9v4pCeGoFnZ1Xaj1oJneGfiVGcDC1nMRs,48258
+torchmetrics/classification/precision_recall_curve.py,sha256=uDIdQqBLI4TRPb0kd-rE2bTUDwqpzxKj7FgJVcMOtEE,35413
+torchmetrics/classification/ranking.py,sha256=KHs7A1VZvDIZmZWMzpAW34yi9DStNTzU77iuOpo3cCo,18332
+torchmetrics/classification/recall_fixed_precision.py,sha256=gahv-ypAqMrkUY60uAL1OSEtqQimWctLievklKJLJqY,25272
+torchmetrics/classification/roc.py,sha256=tN3bZ56NdyhyyvVLki1fdMzAZRf1W3_dUwH1V8IgAB8,30543
+torchmetrics/classification/sensitivity_specificity.py,sha256=ml2-satmeUB6uKpy_meXeaHHIIZAEnlJ8erR8S9i-AI,18702
+torchmetrics/classification/specificity.py,sha256=KvZwwWhaL3h1ZR5lSnJ748ChLno-uq_kbT8x-M9vMtM,23645
+torchmetrics/classification/specificity_sensitivity.py,sha256=qc59pDyFIXxPNMZIy_6ikOLmsCovyYDCxIkxR8mro8s,18811
+torchmetrics/classification/stat_scores.py,sha256=MOVEwrA6kt0SaSMKrx9DOsg-6-0lL-25lu-aIhYY-2Q,26230
+torchmetrics/clustering/__init__.py,sha256=7i2WpseBvmmLmBboB6CSCZiU_WebDOaM1KGUMLT0PEY,1794
+torchmetrics/clustering/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/adjusted_mutual_info_score.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/adjusted_rand_score.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/calinski_harabasz_score.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/cluster_accuracy.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/davies_bouldin_score.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/dunn_index.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/fowlkes_mallows_index.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/homogeneity_completeness_v_measure.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/mutual_info_score.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/normalized_mutual_info_score.cpython-310.pyc,,
+torchmetrics/clustering/__pycache__/rand_score.cpython-310.pyc,,
+torchmetrics/clustering/adjusted_mutual_info_score.py,sha256=0vi2mjpjSrEFrfoxmZXX0Cf89BD_N7V60CdgZDc6yac,5389
+torchmetrics/clustering/adjusted_rand_score.py,sha256=vtA9yYIaoeStHN6qgn2omjElVvvwK9GEGCRnOqoqHEs,5191
+torchmetrics/clustering/calinski_harabasz_score.py,sha256=tu358N-itZQqrlTT0nA1t0Yu7LXiii9HJRCJ3rgghno,5357
+torchmetrics/clustering/cluster_accuracy.py,sha256=D7_Qr8feZ7AD75lOESldMuC79e5SV8yDxpAVrV1x7p0,6034
+torchmetrics/clustering/davies_bouldin_score.py,sha256=4-S5yAgbH4g2Q6id4SkB6BkaJok49DKg2kRp_k9SZJ4,5478
+torchmetrics/clustering/dunn_index.py,sha256=dfGpxsESjwFErInYSac345XE_aWj9rzfhehZq6xpFcI,5014
+torchmetrics/clustering/fowlkes_mallows_index.py,sha256=Yl5qiFxoH3_Nf5XjGipRLKeUR81NCZk1oQifc2Ppyhw,4619
+torchmetrics/clustering/homogeneity_completeness_v_measure.py,sha256=j2JlfxjUPdVvy01lELlyvwZ0ri4OqyoXw4yN15S_J08,12969
+torchmetrics/clustering/mutual_info_score.py,sha256=VyZqKcF4qMGZwLPX-_UmGW0ZFE8OpLj9wJU520aaoVw,5044
+torchmetrics/clustering/normalized_mutual_info_score.py,sha256=Xt0NuydOkm0dZ6wGnm-oHxU8tjTe16Opsuf9tnThNJE,5282
+torchmetrics/clustering/rand_score.py,sha256=kFZzSBMXtSex74q4XFNwdFFNRrfp5hbuV4GEqSjKdhY,4886
+torchmetrics/collections.py,sha256=swVhMCOmaRfV55Y56SrZw1ENzMBD6lQXYW_EhhLz24g,33319
+torchmetrics/detection/__init__.py,sha256=52oQOnyWr0b4Pa5do22VYW2kcdK1wxc1ct-LqnCHLC0,1398
+torchmetrics/detection/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/_mean_ap.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/ciou.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/diou.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/giou.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/helpers.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/iou.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/mean_ap.cpython-310.pyc,,
+torchmetrics/detection/__pycache__/panoptic_qualities.cpython-310.pyc,,
+torchmetrics/detection/_deprecated.py,sha256=SSLnxdFWx8BAFTd5Rd8salDvHP0TUCwjQxV2vEpu14g,2359
+torchmetrics/detection/_mean_ap.py,sha256=FH-1pw2HFUIqYpM6fJn5i8YRHABxJpPhO7nEMSg5-4Q,43130
+torchmetrics/detection/ciou.py,sha256=S0D_1Nh8-IvI5jpeI71I7TdZttAFwDRo03wJaaYxKp4,8176
+torchmetrics/detection/diou.py,sha256=PjjWFXu8Vfxpf4NYVVOo5fAUBFHuQo1RiN0cFVk3z48,8133
+torchmetrics/detection/giou.py,sha256=_0SaXFbtLcQUZAfzakl8AIZAR3uDeC2EO_PC41m97eA,7899
+torchmetrics/detection/helpers.py,sha256=Q6UpNZ00BC2RMRsTYV-NOj7X6HQFDdOXTfq8kmdHC3s,36145
+torchmetrics/detection/iou.py,sha256=swTsOn1r768KYd6lpEhsRinBBDmHlmopBuNfYtg3nPU,13195
+torchmetrics/detection/mean_ap.py,sha256=tDxJHsFaCf2uihU8QOPL7yIZcDbbg8ujMKCuWFhVBbk,33109
+torchmetrics/detection/panoptic_qualities.py,sha256=gVOdRYu9wcrmj-NCfSJbbQOfsR-vMpNzmKa075Qmkbg,22057
+torchmetrics/functional/__init__.py,sha256=8_bsjdxoMayi-o2VvkSrHc34-lHyrlDKpForqSsS4SM,9825
+torchmetrics/functional/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/audio/__init__.py,sha256=Wm3T4Yg21V1PQz8K_oviNepH26pLxipN_dcoXDwp_1w,2744
+torchmetrics/functional/audio/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/dnsmos.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/nisqa.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/pesq.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/pit.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/sdr.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/snr.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/srmr.cpython-310.pyc,,
+torchmetrics/functional/audio/__pycache__/stoi.cpython-310.pyc,,
+torchmetrics/functional/audio/_deprecated.py,sha256=Nsfcx04pVCRoFOHP7QSGOYiNNpEBrNViYr9k0uBxdzY,4431
+torchmetrics/functional/audio/dnsmos.py,sha256=h4zYSzUd7i0YDYRsaOG2BuUk8wiwvm4FG0C4mTQVOyY,11843
+torchmetrics/functional/audio/nisqa.py,sha256=XH6yDuY06sHESP3tSKZrr5CLx2qedO8uOGHe7bxkP9E,16465
+torchmetrics/functional/audio/pesq.py,sha256=Da09vsLFJngu4hGibzHLF2Jnpfu-FnlMf8BDLfbBH18,5029
+torchmetrics/functional/audio/pit.py,sha256=Ju7x4uL4PTJE0tdKQFaSqrPMxQnfBxAokaPDxRbwO3I,9834
+torchmetrics/functional/audio/sdr.py,sha256=PC5NwI7Py-CmrirHCebelerStEhRRfJ_43fJXiLBEk8,11910
+torchmetrics/functional/audio/snr.py,sha256=jrr7-_oSTXw_qHUgGUTaaQ063OJDw2UpGuaxVFP9LOg,5002
+torchmetrics/functional/audio/srmr.py,sha256=ktp7whxQrKm3kU6XP9yvdvn0x1d5jjaYfLdt7azPTsA,14170
+torchmetrics/functional/audio/stoi.py,sha256=g6rfViTkjy9zA-_Iit6VMTYDRPO3kVg-OekrVtESzRA,4217
+torchmetrics/functional/classification/__init__.py,sha256=fywVnR_Hdh9zW7DHuqMx2COZqPjN2UaKSqAqM-VZKgk,8295
+torchmetrics/functional/classification/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/accuracy.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/auroc.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/average_precision.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/calibration_error.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/cohen_kappa.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/confusion_matrix.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/eer.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/exact_match.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/f_beta.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/group_fairness.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/hamming.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/hinge.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/jaccard.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/logauc.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/matthews_corrcoef.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/negative_predictive_value.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/precision_fixed_recall.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/precision_recall.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/precision_recall_curve.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/ranking.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/recall_fixed_precision.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/roc.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/sensitivity_specificity.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/specificity.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/specificity_sensitivity.cpython-310.pyc,,
+torchmetrics/functional/classification/__pycache__/stat_scores.cpython-310.pyc,,
+torchmetrics/functional/classification/accuracy.py,sha256=oN2_8ExcHx0E9TcDevuyicC2O2ScMRzUJmtnMluk-oI,20039
+torchmetrics/functional/classification/auroc.py,sha256=s5PhrMKJjoCO6FOOuMFJ0zMp7W6-_JjWnvaFx2WK5bU,23714
+torchmetrics/functional/classification/average_precision.py,sha256=8JLUguxEVel5K6HEQ5xF0FaXnTB9H4NUMEeMv_QYzYw,23577
+torchmetrics/functional/classification/calibration_error.py,sha256=HRg8c73p3uvTykykPx0gPM7UlX-IHgzPBT037z5Quac,16976
+torchmetrics/functional/classification/cohen_kappa.py,sha256=GhLGVkiU6oX6Av99uGNbAiywPE8UF8eoapRMFkVhlIM,11633
+torchmetrics/functional/classification/confusion_matrix.py,sha256=IZtK8pY36posNW7FUEAqViQdGS9amO3r01iXUE23qAw,27785
+torchmetrics/functional/classification/eer.py,sha256=92hHrYFpaJ9AjafQXjkiS2OVXzTvZDXPA4W-Xl6KOCE,13176
+torchmetrics/functional/classification/exact_match.py,sha256=bvJUNWa0VnHNeGC7sQBQZ0RUD3O--ml8gk-YxqlYeg8,11963
+torchmetrics/functional/classification/f_beta.py,sha256=d03WGgnIcF6TBW6XbDELlaqzqxKJL-zTGcQo4LU4hhw,37936
+torchmetrics/functional/classification/group_fairness.py,sha256=IPgJgQsoWuzv5fgst5O4dkYu-1L5kYh8MAifz3kUpqs,16872
+torchmetrics/functional/classification/hamming.py,sha256=AWxWwllptTn0GpNOmewLvatwLKuFgBNr0hDdR64Ujyc,20726
+torchmetrics/functional/classification/hinge.py,sha256=T_cFHhhZKlAkII5Jx5HMAr27IwV0cv9bMzctWuqa7Ks,12404
+torchmetrics/functional/classification/jaccard.py,sha256=upbjIwzZ_ggVezBVNZNWKqltQSiviv4B-N0P5u0y71s,17235
+torchmetrics/functional/classification/logauc.py,sha256=o5P1iu538mLtGDo1n0Rv1as6_HxXDgq3cmhm1hK0g5Q,17864
+torchmetrics/functional/classification/matthews_corrcoef.py,sha256=JJIQigQt7xGoElLHjzEAU2CF5Yqonl_IUzCO3BpF-tY,12855
+torchmetrics/functional/classification/negative_predictive_value.py,sha256=9vO9brzv2Ubmp_LFkKztfcjv0YdapkZm2Ata7DFT-8Q,20655
+torchmetrics/functional/classification/precision_fixed_recall.py,sha256=NMo_KziOn0iJfsLx4suWy0YXAGklpW5ZCy9fqrZdoEQ,18024
+torchmetrics/functional/classification/precision_recall.py,sha256=IWYoKEPs3HUf1Mqf3U9aVMSK0CzjXO74V2iEJ5wS-fs,36816
+torchmetrics/functional/classification/precision_recall_curve.py,sha256=ne1lHINYQVdzmIilMgiNO7_x83v7nB-Pn9bOT4rSBq4,47564
+torchmetrics/functional/classification/ranking.py,sha256=ndKaQlMPDW36EJ6r-2jZZZX7Kr6TGlr4rGrC2Br9z8Q,11377
+torchmetrics/functional/classification/recall_fixed_precision.py,sha256=SjMaETyWPwrZJaV9TX5qFMT50SopeCGwpUVERcKBCXs,21870
+torchmetrics/functional/classification/roc.py,sha256=-3nASnhSc0JKQWJBirp5Oo811bD46tblXyjZxshS-T8,28559
+torchmetrics/functional/classification/sensitivity_specificity.py,sha256=EIVTPmnhASlHBiXSMq4CfqEbdB4FFlctSvqZYhq1ZWQ,22197
+torchmetrics/functional/classification/specificity.py,sha256=U5JhctBhJk7OCgDmnUkfj5fLRBTj9WNuKFdEJ9ci4bg,18562
+torchmetrics/functional/classification/specificity_sensitivity.py,sha256=MBfj89U5MFhdxC_i6T63hjnaq7LxdDZOKmrjJdakSR4,23556
+torchmetrics/functional/classification/stat_scores.py,sha256=cH8JMBweBeFQQ3xDx0ZLuYmfHMw-2bl3y67A5So-MvY,41365
+torchmetrics/functional/clustering/__init__.py,sha256=AD1Is3Bd41C4Ux8pEr3vqbbXKoADPYggpP5Cy2W8Irs,1961
+torchmetrics/functional/clustering/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/adjusted_mutual_info_score.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/adjusted_rand_score.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/calinski_harabasz_score.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/cluster_accuracy.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/davies_bouldin_score.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/dunn_index.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/fowlkes_mallows_index.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/homogeneity_completeness_v_measure.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/mutual_info_score.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/normalized_mutual_info_score.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/rand_score.cpython-310.pyc,,
+torchmetrics/functional/clustering/__pycache__/utils.cpython-310.pyc,,
+torchmetrics/functional/clustering/adjusted_mutual_info_score.py,sha256=u8Bu-7oXp9SFnuhJw_Ni2Q3T_4UvJQAX6aym71bcFjw,4470
+torchmetrics/functional/clustering/adjusted_rand_score.py,sha256=S63-9ipbJ2xwdzDzkjpjKoU5AK18ajumXqJXhFIF-uU,2422
+torchmetrics/functional/clustering/calinski_harabasz_score.py,sha256=A0KO1NQQOjXKNIK0o33dr0IKfMI1-t59W7aDIAOs9SY,2432
+torchmetrics/functional/clustering/cluster_accuracy.py,sha256=CABBa3QK11i_OZG6eoDRI6fA-n1PMM0Jhmy9fofgI6g,2538
+torchmetrics/functional/clustering/davies_bouldin_score.py,sha256=kocPnHdOgG-fUB7GcAeUzqAOjkzXCT8LFf4SZQtVJCQ,2595
+torchmetrics/functional/clustering/dunn_index.py,sha256=tNmaPqi-3ageHHruNbz0f5hJ8VgkS55KG6irCGPKKls,2764
+torchmetrics/functional/clustering/fowlkes_mallows_index.py,sha256=fvY5b869WfAyEcoAnNKH6uYhNBgBcIbWBKI-AOIeaWI,2477
+torchmetrics/functional/clustering/homogeneity_completeness_v_measure.py,sha256=gQFqVNpPyef8RtVxkd4snud8Ku8fTzQWlGlYYXb8w6Q,4374
+torchmetrics/functional/clustering/mutual_info_score.py,sha256=DOAZhmgC-Qj3-gtaR1XahDr6CsjLKf_bLo5OBiofmFY,2616
+torchmetrics/functional/clustering/normalized_mutual_info_score.py,sha256=QUqPGhyJqckNjzMo1_2xgbmvTkCV-e-bw78vlsyKIDg,2104
+torchmetrics/functional/clustering/rand_score.py,sha256=wpZODfoQXhG_nstuB0bmieB4aHpdMZksxWlJNtBv40g,2602
+torchmetrics/functional/clustering/utils.py,sha256=5XXzlUNdMKZj7kEpvGjjBYEjnljHudiy_RAu7QYIKaU,10090
+torchmetrics/functional/detection/__init__.py,sha256=Xo65qcNkcJbQTpex3Ym8JTIlOXkNt66G1ae7wpeVbYQ,1510
+torchmetrics/functional/detection/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/_panoptic_quality_common.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/ciou.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/diou.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/giou.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/iou.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/map.cpython-310.pyc,,
+torchmetrics/functional/detection/__pycache__/panoptic_qualities.cpython-310.pyc,,
+torchmetrics/functional/detection/_deprecated.py,sha256=QOLkrR_L5cYascVaOz58mm32DTe-gjFGDqTKcB56sro,2308
+torchmetrics/functional/detection/_panoptic_quality_common.py,sha256=A7LctJ-pmMMJpB4qCXhNRhpH5A4-60FcJRv3IPIMIss,20147
+torchmetrics/functional/detection/ciou.py,sha256=GDPVS1z0tLlGpZqSvJHHhK0R-aIKeq1nt84Jar3S0hY,4912
+torchmetrics/functional/detection/diou.py,sha256=D9-UygjNRESR6ft__AG0pFgBGn0q6F_gZlwfUd5yiFA,4914
+torchmetrics/functional/detection/giou.py,sha256=TYCYK6-2U2UPhnrrmsgePc8T9yfxKiXRFmhsR9_O3fs,4918
+torchmetrics/functional/detection/iou.py,sha256=k-pVlsypkbaPPDRtPJJMyR8tjUBLxes-VM8efgK32oU,4833
+torchmetrics/functional/detection/map.py,sha256=TXMFJC8hoPVkkzYA2omYwzM42XYOPhnYqWAh3K6UCmM,9732
+torchmetrics/functional/detection/panoptic_qualities.py,sha256=rR3_bXo4hS8e1KZ9NRzIIwzu9FCZSoZP9I-st0Ev4Zk,11547
+torchmetrics/functional/image/__init__.py,sha256=n4FQ3CJqqtODHOHpWmT3DQlg1e6f7YpXgoHqDuctBts,2890
+torchmetrics/functional/image/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/arniqa.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/d_lambda.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/d_s.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/dists.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/ergas.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/gradients.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/lpips.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/perceptual_path_length.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/psnr.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/psnrb.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/qnr.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/rase.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/rmse_sw.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/sam.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/scc.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/ssim.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/tv.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/uqi.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/utils.cpython-310.pyc,,
+torchmetrics/functional/image/__pycache__/vif.cpython-310.pyc,,
+torchmetrics/functional/image/_deprecated.py,sha256=5UaCvIG8KZPdhwHV4tZKwIFCiHCQngWa9oju0isVFx8,8940
+torchmetrics/functional/image/arniqa.py,sha256=DL71C6UqeMBiLv_CQ4psGQZ6BSSY0wfb0r_DoDcOyv8,12220
+torchmetrics/functional/image/d_lambda.py,sha256=rivTjYLrmJhdZSPcNtIHGrdVcAMTnxqIPQPlZ_0UMvE,5623
+torchmetrics/functional/image/d_s.py,sha256=dElq0cbZcSc00f9JQRhxSn3Qas-rzVOjRuvr1rdQDPc,11095
+torchmetrics/functional/image/dists.py,sha256=V3-TWDXgaPhC_2gp7gMlls_X46b4eWdJFG6SifsKG94,8930
+torchmetrics/functional/image/dists_models/weights.pt,sha256=9eZcliMLf2yplWkWR9SCI35Mq4pQxcSleE8hnvB0ghg,12288
+torchmetrics/functional/image/ergas.py,sha256=S0nZ6EHupd9e5yu9XRFyf-Pngwisv5TX_65niiKbXko,4167
+torchmetrics/functional/image/gradients.py,sha256=GiniMRsV22SoyGWxs087in4G9itrWt_wNHftxC4oKA4,2886
+torchmetrics/functional/image/lpips.py,sha256=tkftKrTUZiKJMczXD6HvUd5h3Zt8_DCOvbKOPUutqIo,17630
+torchmetrics/functional/image/lpips_models/alex.pth,sha256=33MoXjWyI1Wi34fNtrcLNDcTtmft29pz4Zd-DIYINcA,6009
+torchmetrics/functional/image/lpips_models/squeeze.pth,sha256=SlNQ8jYAy3mSPOZbsHy_V9ykYTKYlBU-BaE0a9Uxz3Y,10811
+torchmetrics/functional/image/lpips_models/vgg.pth,sha256=p4kooK8eXw_LHzuej4w6Klo94kTYMK1cH-3cebhDKGg,7289
+torchmetrics/functional/image/perceptual_path_length.py,sha256=Xh_Em1YMdxm7z3hQcKQ6qcU0h9PoA6PJXbBDHCYWohA,13741
+torchmetrics/functional/image/psnr.py,sha256=fbM3yUNPLyR-oh7qgIHB81pkFCQzXeiheLzAtWdf4OI,5560
+torchmetrics/functional/image/psnrb.py,sha256=jcyB5f7jSUtM5swlYZRRlDydF8zAj4dfUr70Zp8mpQ8,4858
+torchmetrics/functional/image/qnr.py,sha256=Y91qy2uOjRFeqQQEJtKibyhHAYwfF61azcnJ26tPfb4,3201
+torchmetrics/functional/image/rase.py,sha256=AeIk9mkg18dIUor6QD472wINP41MuB3Trm0C_-a1p6U,3980
+torchmetrics/functional/image/rmse_sw.py,sha256=QsHOEd7csxo8TNaAmD5Umkjb4ArFEH0QOOAyg_3-J0U,5546
+torchmetrics/functional/image/sam.py,sha256=nMIZS7cVLPPUIBOmK_IHWGjNqRKPq2ZLvCrq9U8s5hI,4198
+torchmetrics/functional/image/scc.py,sha256=V8PdnvMxGfZr3cWs3p_gV47V_pnZHUSWHDpCtN4f4OM,8610
+torchmetrics/functional/image/ssim.py,sha256=upztfW16SDf8NKHKYQSodPOHxMKc7Y6mYo_NU34O7OA,21771
+torchmetrics/functional/image/tv.py,sha256=bQmlbCqN4Mt_gRtPrABhe3Qq3LiTOGpOQRl-Vu8A78c,2799
+torchmetrics/functional/image/uqi.py,sha256=Vu5myFN9iwfeW-SWNxeheG5I-6QLmAe4CFArmd9p538,6566
+torchmetrics/functional/image/utils.py,sha256=Suy8BfPBTakcEd01IauLTdfGCfNZgOVKcgmVePrGByc,6013
+torchmetrics/functional/image/vif.py,sha256=9b6VpqMk9DmHdxXBuka0lkAj37yCJCdleUu5nRfN5nY,6419
+torchmetrics/functional/multimodal/__init__.py,sha256=MwecONDNOv7y6xnyDNUt2_c3jIaNFYjU70CBNgAoDx0,1019
+torchmetrics/functional/multimodal/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/multimodal/__pycache__/clip_iqa.cpython-310.pyc,,
+torchmetrics/functional/multimodal/__pycache__/clip_score.cpython-310.pyc,,
+torchmetrics/functional/multimodal/__pycache__/lve.cpython-310.pyc,,
+torchmetrics/functional/multimodal/clip_iqa.py,sha256=jbyyAUOBnw8e_EcABnJ3l1gUfnHcel3FWFJQfJfD__I,15942
+torchmetrics/functional/multimodal/clip_score.py,sha256=Tx38ulxuK4nc9vS4L6u4OivCVafVytwl4MWOGDv_BX4,15186
+torchmetrics/functional/multimodal/lve.py,sha256=6KKx7TtTPdaoxdEi9hbpLh3yb8i2hrxHPHGc9BUnX90,4398
+torchmetrics/functional/nominal/__init__.py,sha256=JDtSc1P4crHRJSQb6PXymlWykb4-eGed-kLHVzNHpI0,1285
+torchmetrics/functional/nominal/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/nominal/__pycache__/cramers.cpython-310.pyc,,
+torchmetrics/functional/nominal/__pycache__/fleiss_kappa.cpython-310.pyc,,
+torchmetrics/functional/nominal/__pycache__/pearson.cpython-310.pyc,,
+torchmetrics/functional/nominal/__pycache__/theils_u.cpython-310.pyc,,
+torchmetrics/functional/nominal/__pycache__/tschuprows.cpython-310.pyc,,
+torchmetrics/functional/nominal/__pycache__/utils.cpython-310.pyc,,
+torchmetrics/functional/nominal/cramers.py,sha256=Ot_7UFSz_Pv-73eNoUFdzUywPwdPw__de9wDiCOBN_Q,7340
+torchmetrics/functional/nominal/fleiss_kappa.py,sha256=3vjLTQ8Qs5wTWosHjJ4-7RFaBnAivrA3EedNMa2xYzg,4226
+torchmetrics/functional/nominal/pearson.py,sha256=7SZeWnwTzvgxHD7_8oBHsQKoGJtUiRsO5OJ1TZkqf9g,6875
+torchmetrics/functional/nominal/theils_u.py,sha256=APxXfi7RFrrdPhfmBQ2ux1pWjOZ1ALN9dICMf6SQafA,7107
+torchmetrics/functional/nominal/tschuprows.py,sha256=6la3UCp8aPIzfTxT80bvmS9qpI5CmS8FxQAlShFCz1k,7639
+torchmetrics/functional/nominal/utils.py,sha256=8S75LS3YDDKBlSny5rgurDQUi9_yU9IGwr8c0rtGTfM,5745
+torchmetrics/functional/pairwise/__init__.py,sha256=f1NY4J7hgdcrpKk2yLHXF9yojm8qbGOmB8G4h9jrVRk,1173
+torchmetrics/functional/pairwise/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/pairwise/__pycache__/cosine.cpython-310.pyc,,
+torchmetrics/functional/pairwise/__pycache__/euclidean.cpython-310.pyc,,
+torchmetrics/functional/pairwise/__pycache__/helpers.cpython-310.pyc,,
+torchmetrics/functional/pairwise/__pycache__/linear.cpython-310.pyc,,
+torchmetrics/functional/pairwise/__pycache__/manhattan.cpython-310.pyc,,
+torchmetrics/functional/pairwise/__pycache__/minkowski.cpython-310.pyc,,
+torchmetrics/functional/pairwise/cosine.py,sha256=CPg8_Q4hLUe6YymgbZiCir1FtSWmnYROnXZpv5LYnyw,3499
+torchmetrics/functional/pairwise/euclidean.py,sha256=p9WZz6TBwQS25cZKDcU-6_tnDwF5OOTtkTIUBE2whq0,3449
+torchmetrics/functional/pairwise/helpers.py,sha256=8gZxrpBBUuRJdUnx49JUloeAlwgH3gM8-Ul8VBilKzs,2246
+torchmetrics/functional/pairwise/linear.py,sha256=OLOP2usOlbPOzD05vXlnWLlHkGgS68x94lP7UmRdkJU,3176
+torchmetrics/functional/pairwise/manhattan.py,sha256=zXQBFhxpmYzVtXSclM7sIPHXWXea-1tSmszU4CrjUng,3196
+torchmetrics/functional/pairwise/minkowski.py,sha256=jkms9LhEdX5yE9aezLKZXk3KeLi3EfLsPjUfxTlwCTQ,3999
+torchmetrics/functional/regression/__init__.py,sha256=NhakHreDD8TvYs7wk0aFEJ72pHeCC6I_rIJFHy_rRgw,3045
+torchmetrics/functional/regression/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/concordance.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/cosine_similarity.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/crps.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/csi.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/explained_variance.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/js_divergence.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/kendall.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/kl_divergence.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/log_cosh.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/log_mse.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/mae.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/mape.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/minkowski.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/mse.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/nrmse.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/pearson.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/r2.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/rse.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/spearman.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/symmetric_mape.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/tweedie_deviance.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/utils.cpython-310.pyc,,
+torchmetrics/functional/regression/__pycache__/wmape.cpython-310.pyc,,
+torchmetrics/functional/regression/concordance.py,sha256=PKw3PFNytnMbVY1DLdVcYJPoeymqCxzm3JFW1yY2F9I,3340
+torchmetrics/functional/regression/cosine_similarity.py,sha256=OGlqnXQZe6I-JSTmbhRQDhip9UQi_OWfEZ1xgjGU_0s,3628
+torchmetrics/functional/regression/crps.py,sha256=md5MRhhKUlJhMyzkXBIg4W58VMiWj9Cn1kRw5V7Wphs,3767
+torchmetrics/functional/regression/csi.py,sha256=0pURdVheU2yk5neMLcdbv8KTmLIn3z8t5QYs-Col92c,4855
+torchmetrics/functional/regression/explained_variance.py,sha256=ul817GvdESRyAI8e9veAiv1RJQWw2HnOigA5YKzQT9o,5492
+torchmetrics/functional/regression/js_divergence.py,sha256=l6WIe1R6AGKCwdmxBoaO06IPV4oGvWNc-MI8BQA7MBU,4237
+torchmetrics/functional/regression/kendall.py,sha256=AG4AzLnwP-o3QawCaXlaSpsndBhkaYtmTRUf2I4kpPc,15816
+torchmetrics/functional/regression/kl_divergence.py,sha256=6C7eQPvQgoH-jDFzRU3txjv_RedCyfTcNouQlFrOu3Q,4392
+torchmetrics/functional/regression/log_cosh.py,sha256=-xCnETLaQ6e5o2N7jiORi7wtsv9dhIIiccFrKZxZ6Ck,3500
+torchmetrics/functional/regression/log_mse.py,sha256=HjJy6qvVFo4MsmFPT6KkMVQs1n4iCaH_t6Ucw2xpi08,2598
+torchmetrics/functional/regression/mae.py,sha256=Vysyes-BPJ2xk42x07eEuiJ3bg7GJ-W-hj5m80ci-NA,2855
+torchmetrics/functional/regression/mape.py,sha256=1UHopkH9KN-KYB9qOSGklkUqFqN1KAS-WkPAmVVDNZE,3023
+torchmetrics/functional/regression/minkowski.py,sha256=sQYgJm2edpTZhTDIVAyGGZjJ9EAzgoeF8cB-j64GMMU,3010
+torchmetrics/functional/regression/mse.py,sha256=pNg7uuCSvTqjQrG2XiYbsZKn5CZIrndzP3ZGFCduMcE,2893
+torchmetrics/functional/regression/nrmse.py,sha256=07f9JsO9PYf8P4UlsuMISnK7eORJPsuwE5DVS6Oi1bk,4376
+torchmetrics/functional/regression/pearson.py,sha256=u2S2HXDzHD55V7XhHtfukpROXiqtDFniJnnmcKr7UVg,7368
+torchmetrics/functional/regression/r2.py,sha256=M6NC_RAOHNtldiUENV7R1L2pvsnVoo5WpxzAdnVE__M,6613
+torchmetrics/functional/regression/rse.py,sha256=o8AFBRGSS2Evcux83H6IEn6PuywjpJZC6fg9e9Y3y6A,2945
+torchmetrics/functional/regression/spearman.py,sha256=G1hn6br1BpSDMEZ8HJS_axHPNNHyxkflW107ZhK9k2s,4723
+torchmetrics/functional/regression/symmetric_mape.py,sha256=Kt2Y3v6sTEdLCA0M5YOBgoLPtJC6Jff5utmbdDSZMeI,3298
+torchmetrics/functional/regression/tweedie_deviance.py,sha256=3Z-kVkKUDvUUxDtjiyqAUot2KOrzHPDJ_lVH9mSwRJw,6071
+torchmetrics/functional/regression/utils.py,sha256=J5w3uY5qnyeoibifzsIwxE7cAm7ooFEVW--k4qDGFkU,1805
+torchmetrics/functional/regression/wmape.py,sha256=z8SRSBAg_lTAJemBpfuat-B_kU_fl5Y1sLv0cj9Qf8c,2615
+torchmetrics/functional/retrieval/__init__.py,sha256=hQRnCa7zEI8V_VhJSCWwJL3VDjWz1blooSUiq98gvJ8,1688
+torchmetrics/functional/retrieval/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/auroc.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/average_precision.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/fall_out.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/hit_rate.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/ndcg.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/precision.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/precision_recall_curve.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/r_precision.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/recall.cpython-310.pyc,,
+torchmetrics/functional/retrieval/__pycache__/reciprocal_rank.cpython-310.pyc,,
+torchmetrics/functional/retrieval/_deprecated.py,sha256=N-MbyyAnk_u6zeaf83wK-TMv-E1aVu39JYXayStaH7g,5410
+torchmetrics/functional/retrieval/auroc.py,sha256=1pqKdtd8kektGa03au4NKvtedoIoD8FydMY5tZ9U3Zo,2663
+torchmetrics/functional/retrieval/average_precision.py,sha256=5MDU0IJiHv5CWaPqY2-8Li9XuibiAxZjvz-kUTgYivE,2676
+torchmetrics/functional/retrieval/fall_out.py,sha256=Q2M7qmf57NyWYRdWAvNUbyQEbY_nWVWFA_Ftahluybs,2671
+torchmetrics/functional/retrieval/hit_rate.py,sha256=CpkO2zLnBxreNCQVvF7neJD7m9lVmUc72fhTi0KrWQk,2409
+torchmetrics/functional/retrieval/ndcg.py,sha256=tZky3qj7gmM8wZeqZHAFLn7spAIkpGpm0i_NPWLwjII,4328
+torchmetrics/functional/retrieval/precision.py,sha256=Wf1NpSk2WUgwmjXnBGNltH-qqHwCcBzcz1JpDPTa5H8,2847
+torchmetrics/functional/retrieval/precision_recall_curve.py,sha256=uiCXPAtjOekAuhxHQoV5yDQmBfKcJbQNHMbLz0rXP_g,4037
+torchmetrics/functional/retrieval/r_precision.py,sha256=DpxPzInI5c5Fdz1-JLLi99P32Z6iJfGltFAk7l4bkfM,2121
+torchmetrics/functional/retrieval/recall.py,sha256=HGhXI7BRjNGkSNk-z4xEN_yNMfpMRdv0o6GGXz2RuYQ,2593
+torchmetrics/functional/retrieval/reciprocal_rank.py,sha256=XtA4BSXu5Keuy5tDVXVRNkcvPG0KqQdFAp660yYN6UE,2518
+torchmetrics/functional/segmentation/__init__.py,sha256=i0DFQxUagC0C0AHT30H9i-32lzwtMu6Ev1kG_v5LfGc,972
+torchmetrics/functional/segmentation/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/segmentation/__pycache__/dice.cpython-310.pyc,,
+torchmetrics/functional/segmentation/__pycache__/generalized_dice.cpython-310.pyc,,
+torchmetrics/functional/segmentation/__pycache__/hausdorff_distance.cpython-310.pyc,,
+torchmetrics/functional/segmentation/__pycache__/mean_iou.cpython-310.pyc,,
+torchmetrics/functional/segmentation/__pycache__/utils.cpython-310.pyc,,
+torchmetrics/functional/segmentation/dice.py,sha256=hxZpHtPh1Lo6km2Kg3aIzWoEfENlEvGS5k3AqE0bgEc,8807
+torchmetrics/functional/segmentation/generalized_dice.py,sha256=0MVbNWf1RD6pOGPPAY663inK_QS0ZYA1HhV_aMhtyvQ,6838
+torchmetrics/functional/segmentation/hausdorff_distance.py,sha256=ahBDXnaNrdAY_xxPAA79UdUmrA75Ejl1S6HBXaYVXuA,4940
+torchmetrics/functional/segmentation/mean_iou.py,sha256=fB5ex8V5ibeRTmSfPZ4xQ7XeTl_Giisj3w3J6OMU1lo,6786
+torchmetrics/functional/segmentation/utils.py,sha256=d4M7lahG2YDouysZ_rSojoFXTSYats9gHLR9wUyTLSk,50136
+torchmetrics/functional/shape/__init__.py,sha256=FxPrVkJAILigFAzOdvGI98m-dVSrwwn6Nw_Wr_8wWzo,688
+torchmetrics/functional/shape/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/shape/__pycache__/procrustes.cpython-310.pyc,,
+torchmetrics/functional/shape/procrustes.py,sha256=nDlQc3WczwcIGISPEWtjOrn-i2p7uLQfsgfpigHtl50,2728
+torchmetrics/functional/text/__init__.py,sha256=kEA3cUZAlO9SLXyUNgb71p_ZX9CNlxwxhfLhyIYJYIU,2067
+torchmetrics/functional/text/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/bert.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/bleu.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/cer.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/chrf.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/edit.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/eed.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/helper.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/helper_embedding_metric.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/infolm.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/mer.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/perplexity.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/rouge.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/sacre_bleu.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/squad.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/ter.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/wer.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/wil.cpython-310.pyc,,
+torchmetrics/functional/text/__pycache__/wip.cpython-310.pyc,,
+torchmetrics/functional/text/_deprecated.py,sha256=1332p3ojAoUPQabLW3u2aEwA0ymH-RwT9XuizxW4Fk0,13963
+torchmetrics/functional/text/bert.py,sha256=BS9sruyRl96OgwAKH0Qo7TriKFK9i6iy2XrsXQeF758,26746
+torchmetrics/functional/text/bleu.py,sha256=P2F2FZN-dVz7GHTbXTTTgprhcwWddZ7uc5jSHpsYFl8,7598
+torchmetrics/functional/text/cer.py,sha256=QPsm_kUS_FKnjVOcxF6SORQyF1TuBhTLsXuZ87yWfGM,2970
+torchmetrics/functional/text/chrf.py,sha256=L5CMw4D5h3gB9wnvsAVytcyupYmBrzM-G0JS1M7Rpbo,25904
+torchmetrics/functional/text/edit.py,sha256=MqHGLvmkM4NkXbfKUpcHlOu1hfnVknR92gGOlL0x_Hg,4806
+torchmetrics/functional/text/eed.py,sha256=HyNCFszmsatkGhGyFS6hoDVtyqjyNB3wJWV7n_ZXME4,17569
+torchmetrics/functional/text/helper.py,sha256=2AUG95KbGxyAfDgzdJt8V_uvfttPGgFAlfsN5fFFjtI,17004
+torchmetrics/functional/text/helper_embedding_metric.py,sha256=PQId2tnXovGDNrbGIf-My7fCNb3i9om8UIUu18XcwWo,12021
+torchmetrics/functional/text/infolm.py,sha256=yKowb2NjeDvYM1GoBxQJLxbMB88Ayixcqg_O8AE4Zps,28027
+torchmetrics/functional/text/mer.py,sha256=roRGGKGcfpeId3yA2X7pwehlD9wF0CBi3wv4TocA5TE,3018
+torchmetrics/functional/text/perplexity.py,sha256=AaKgl3u-bb7IOpIKBAIVjyswga6ys5gH5clt2kEYAYI,5304
+torchmetrics/functional/text/rouge.py,sha256=hMB_kehukr2s49xrWxG5A8BmuHkUyCixhHjkeFeR7Q8,20727
+torchmetrics/functional/text/sacre_bleu.py,sha256=jGBFcdKPLPPRHBYVbfZiU_Wut6G3EhJlI9pNkzvSDbE,20151
+torchmetrics/functional/text/squad.py,sha256=yu_vNl5X5HX_um5TN1wVsvbc0ta5i7TxexyTy9CcdC0,9869
+torchmetrics/functional/text/ter.py,sha256=Gqesb980zS2Rvw0n9dTtL3kZ2nuQvubRjb_q96fuyPs,23280
+torchmetrics/functional/text/wer.py,sha256=Qpwg0IRR5oTPK1G3XMqUbaJHZW-5mHVuwBOz3Pvfl-8,2961
+torchmetrics/functional/text/wil.py,sha256=IhJ8FOiuzaFc7agGszacKzbIjLqVqLEWfuebMylrNAk,3496
+torchmetrics/functional/text/wip.py,sha256=jJHXGA1Df-VkFU3JmN1NMZrGGTydgVsBk-AoehmAJAY,3500
+torchmetrics/functional/video/__init__.py,sha256=Fve47SWsGruroKBLzyymNUhLL8mBMKlW2LFpsESL-bM,829
+torchmetrics/functional/video/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/functional/video/__pycache__/vmaf.cpython-310.pyc,,
+torchmetrics/functional/video/vmaf.py,sha256=n_Vdt684JgukFyoByDXMpiS324UnpSvSGfZrkESa2p4,6979
+torchmetrics/image/__init__.py,sha256=AFPaVQ3iZqacAYCBUaGZFQQImrLd1yI1PagSvf8dv0c,3038
+torchmetrics/image/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/image/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/image/__pycache__/arniqa.cpython-310.pyc,,
+torchmetrics/image/__pycache__/d_lambda.cpython-310.pyc,,
+torchmetrics/image/__pycache__/d_s.cpython-310.pyc,,
+torchmetrics/image/__pycache__/dists.cpython-310.pyc,,
+torchmetrics/image/__pycache__/ergas.cpython-310.pyc,,
+torchmetrics/image/__pycache__/fid.cpython-310.pyc,,
+torchmetrics/image/__pycache__/inception.cpython-310.pyc,,
+torchmetrics/image/__pycache__/kid.cpython-310.pyc,,
+torchmetrics/image/__pycache__/lpip.cpython-310.pyc,,
+torchmetrics/image/__pycache__/mifid.cpython-310.pyc,,
+torchmetrics/image/__pycache__/perceptual_path_length.cpython-310.pyc,,
+torchmetrics/image/__pycache__/psnr.cpython-310.pyc,,
+torchmetrics/image/__pycache__/psnrb.cpython-310.pyc,,
+torchmetrics/image/__pycache__/qnr.cpython-310.pyc,,
+torchmetrics/image/__pycache__/rase.cpython-310.pyc,,
+torchmetrics/image/__pycache__/rmse_sw.cpython-310.pyc,,
+torchmetrics/image/__pycache__/sam.cpython-310.pyc,,
+torchmetrics/image/__pycache__/scc.cpython-310.pyc,,
+torchmetrics/image/__pycache__/ssim.cpython-310.pyc,,
+torchmetrics/image/__pycache__/tv.cpython-310.pyc,,
+torchmetrics/image/__pycache__/uqi.cpython-310.pyc,,
+torchmetrics/image/__pycache__/vif.cpython-310.pyc,,
+torchmetrics/image/_deprecated.py,sha256=V2udahUjZqO7FBoodf9FlfxbFmRHT2XymEMC2W-UGhk,8504
+torchmetrics/image/arniqa.py,sha256=gGjqflHrL9jgsp8oa2_r-MNY2zuBOlTVo6eotLLx3aM,9242
+torchmetrics/image/d_lambda.py,sha256=xJsrJdC83iTEAfVsd8kSmKnObu68ccZ08j0-XFGXV_4,6006
+torchmetrics/image/d_s.py,sha256=l8MuZnTsNxHjizN_NsV97aPi-0D4ghQe5QKxtBz2J_4,9464
+torchmetrics/image/dists.py,sha256=jvoJwZXC0Tbbht99VMXOkP_u4PgQDczY6eaDyefLqOk,5725
+torchmetrics/image/ergas.py,sha256=NydrHyzRsjcv9D93D71JBXsezj7ZVuDXPPvYV3Hd1eA,6240
+torchmetrics/image/fid.py,sha256=C3E2rkub7mE5nmKlnRSOC3E-GfmXv4Q8SKJL49OMLMo,22297
+torchmetrics/image/inception.py,sha256=f_EXhcRKqjgOe14WW5b6mDZ3S3RxK_D0LNl3xr-XRgM,9235
+torchmetrics/image/kid.py,sha256=gVbHNlh_eEnigxP5n1IT9E2tHTpfgKfMIHg7rtsfQpQ,15628
+torchmetrics/image/lpip.py,sha256=ezWAjFgGOYJjg1KZJP6dGPeXsCumLqVwfOWx0Z2QRCk,8460
+torchmetrics/image/mifid.py,sha256=Li_gYCsImp_DModIUFWhyYLnPXWhM87IE1mKv-ILd9o,13101
+torchmetrics/image/perceptual_path_length.py,sha256=cCWEf1DcoiryWgV8M6G2lCuQmeSsW5fHlEi3daED0ks,8523
+torchmetrics/image/psnr.py,sha256=eN5RmFgOpNkhKO4I-7TW_-GGfDygwm1jB0nMFLgqP7w,8512
+torchmetrics/image/psnrb.py,sha256=QQ1mjTw8QdZy5ck6-b3Q8Gh2TcxKRPug_YszyZKlNvg,6181
+torchmetrics/image/qnr.py,sha256=KNJSmtKPmQFoSj8SAacN9eAF-OiXA8n04B_wpfyXke4,9626
+torchmetrics/image/rase.py,sha256=N9Ra1-978iHGldbXEXL2WhqQv2hGlGQBXW2njaPfc8Q,4945
+torchmetrics/image/rmse_sw.py,sha256=joX_z3tlN14IS_wzWOcXzNqAM5Am0tsI09apbCxWtAk,5429
+torchmetrics/image/sam.py,sha256=O33sxzXo7I20d4uPppTUecQU4lwIOM4XTo_747smoTg,6626
+torchmetrics/image/scc.py,sha256=vBh-6K-TFCUnsWxoH-n5l1M363cpA57dYIu_BVA2WrI,3256
+torchmetrics/image/ssim.py,sha256=v23wARQUV9gLQVClRKoynS7oGqn-BnCbAbIkdyU-yFY,19532
+torchmetrics/image/tv.py,sha256=kh38dodRJ63HcImc5Svg5QrVoWFNDaJBbYBwRLnueZQ,5306
+torchmetrics/image/uqi.py,sha256=d75vZMDVnu7DVoBayMT6BjVtf35qKjf0NsDScD_4Y2Y,6843
+torchmetrics/image/vif.py,sha256=_yVSXc0I4OjDqjvs5ljlc0nRzYH16VIRHAaIPF-l6Js,4206
+torchmetrics/metric.py,sha256=jcUIo3QWFG6Dkv3BEBitjIm0GL52VfmiAG4MSBlzoPo,57049
+torchmetrics/multimodal/__init__.py,sha256=GFq8rL-QwcrP4Z4jGc0rIdoSzSMUF6O7a1Ee9hca854,974
+torchmetrics/multimodal/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/multimodal/__pycache__/clip_iqa.cpython-310.pyc,,
+torchmetrics/multimodal/__pycache__/clip_score.cpython-310.pyc,,
+torchmetrics/multimodal/__pycache__/lve.cpython-310.pyc,,
+torchmetrics/multimodal/clip_iqa.py,sha256=ELuh7dqrvhp3D1wZHv86RKTIzVJUoDGJjwvJL8cOkLU,11924
+torchmetrics/multimodal/clip_score.py,sha256=PmslChrtknb-Qo1kfa5g6Wv4GVQE7bE_CmKB6ryf0vs,10941
+torchmetrics/multimodal/lve.py,sha256=RSZGmjtLUTvKgB19-diBROqsABYJlGrvHJuIItk3IWo,8358
+torchmetrics/nominal/__init__.py,sha256=-AbpLuTpceUjVMJz2AQLMY_nnXJJsry75B0hXk2Zkbo,987
+torchmetrics/nominal/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/nominal/__pycache__/cramers.cpython-310.pyc,,
+torchmetrics/nominal/__pycache__/fleiss_kappa.cpython-310.pyc,,
+torchmetrics/nominal/__pycache__/pearson.cpython-310.pyc,,
+torchmetrics/nominal/__pycache__/theils_u.cpython-310.pyc,,
+torchmetrics/nominal/__pycache__/tschuprows.cpython-310.pyc,,
+torchmetrics/nominal/cramers.py,sha256=tuSme3YICwkOLBHQfYizF_lls5w8WqN7E5spBhTFPjA,6272
+torchmetrics/nominal/fleiss_kappa.py,sha256=x7v-mzB5bOLLnTdfoQBkjZTeq4g6Bsonc2o-cJ_J7IA,5664
+torchmetrics/nominal/pearson.py,sha256=gocfEjREFXEJCnZu53cht2IV-n7XNmfrITvsKhsxIcI,6567
+torchmetrics/nominal/theils_u.py,sha256=XjSIcRZwjexE8gZYlYd1GQSCshEstGHgNSUx61qUn_U,5798
+torchmetrics/nominal/tschuprows.py,sha256=H0O-m-Zec_dX3ld4JAHzyaNdww93Rg6LXsSKPMEkQIY,6337
+torchmetrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torchmetrics/regression/__init__.py,sha256=SmayrB6S4UstfYTY7HHgaxA2nwMJwMeF-7PvFdyXb2Y,2675
+torchmetrics/regression/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/concordance.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/cosine_similarity.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/crps.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/csi.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/explained_variance.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/js_divergence.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/kendall.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/kl_divergence.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/log_cosh.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/log_mse.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/mae.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/mape.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/minkowski.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/mse.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/nrmse.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/pearson.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/r2.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/rse.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/spearman.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/symmetric_mape.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/tweedie_deviance.cpython-310.pyc,,
+torchmetrics/regression/__pycache__/wmape.cpython-310.pyc,,
+torchmetrics/regression/concordance.py,sha256=OQBtHYgFxY_qxGxd_lK_WHqK81eszaogMy1INRzVEBY,5841
+torchmetrics/regression/cosine_similarity.py,sha256=a0BEQP0iZY4Qu4CjEW9DqSq4S5_Xuw9Z929SumUltPI,5235
+torchmetrics/regression/crps.py,sha256=Hfhe4_xqmOLFdwJpgChdQohyOqNHUHj5k0VUAqlmrnM,5096
+torchmetrics/regression/csi.py,sha256=RJuh0_bSRyI7cuY4atVuuO7YdDbdEFOshdjdRGpfFRI,4792
+torchmetrics/regression/explained_variance.py,sha256=A5ml_rvQpHUuDcA8wXoMqy2EIi2IvKPE_lkpnEO2J98,6948
+torchmetrics/regression/js_divergence.py,sha256=T36I89jXCsSHYN8SetF0BzqQ5BvV6EnviWgWl8pZkT8,6775
+torchmetrics/regression/kendall.py,sha256=afAcigwQwfuXoGIJoDqMU05Cmwx51wVTy4PIQUvz1Yc,8278
+torchmetrics/regression/kl_divergence.py,sha256=a9_KYNLcMX01gpY4z8Entt1pkuGdFAvnFsbwelzX5Xc,6672
+torchmetrics/regression/log_cosh.py,sha256=5vkae4AqkJtEz_6W4BvtA8tLgHCu3nbvY-Fovxm44wE,5440
+torchmetrics/regression/log_mse.py,sha256=AEyNbkwNrDUQ6ZEAQ7tTbGn5k6asvWR4H3i1NiMEp4c,4720
+torchmetrics/regression/mae.py,sha256=a3tDZxZu_JrIo5-d7SxGlyXsXrIE4reE4fH-Z7flAe0,5307
+torchmetrics/regression/mape.py,sha256=SgekTYO9jJzNDSBJQVOIaROM7DJ8ROFoSm26kkVg2_w,5094
+torchmetrics/regression/minkowski.py,sha256=KnzYJ8jTSwtlPjyNgbYqaBnI4tU7-fTS7G1cGugGgPE,4603
+torchmetrics/regression/mse.py,sha256=wpuUpCfpvnL2-dl0kXHlYzlj8Xz7bNG3VGjsYXHuJUk,5609
+torchmetrics/regression/nrmse.py,sha256=bH7UWG0yJyRNTE2wI9SCrjzCnL8Y5CTX-FRBstTzXoc,10852
+torchmetrics/regression/pearson.py,sha256=u0zeqKtdkoeDaJzyzrKOSd48PvfRBL0b6Ds4AMlHrkI,9769
+torchmetrics/regression/r2.py,sha256=LXCqIE7IAgX3-ScpBYb4ZteQz3nXshZPqnMX83-KCSo,7741
+torchmetrics/regression/rse.py,sha256=EMH0_8wCvULpo1lazBrYZ3BZ3rZA-OVbtGjV9bhA8Ig,5470
+torchmetrics/regression/spearman.py,sha256=dKA9h1qRzp02jtcyFDp-QoeF2FDmfHlCaWswytUwr2E,5810
+torchmetrics/regression/symmetric_mape.py,sha256=Uh_3hQfzGsK6C_feQHeKM718sEKj9paxj-a6K1aEoDg,4855
+torchmetrics/regression/tweedie_deviance.py,sha256=IVHg6nVBEc5j6NuRd9IZlVp5yyxM4ndV3eIlCvdafZ0,5919
+torchmetrics/regression/wmape.py,sha256=205orI6kavTLXE9mdqPuX1bjVtFVazIIhELu8p0g8k0,4848
+torchmetrics/retrieval/__init__.py,sha256=j8ra86FDGJa_lcZDt6VBn45-iQ_Ew3fFVAnYrsedWHY,1566
+torchmetrics/retrieval/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/auroc.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/average_precision.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/base.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/fall_out.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/hit_rate.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/ndcg.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/precision.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/precision_recall_curve.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/r_precision.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/recall.cpython-310.pyc,,
+torchmetrics/retrieval/__pycache__/reciprocal_rank.cpython-310.pyc,,
+torchmetrics/retrieval/_deprecated.py,sha256=nFRag3cnGTSOfEuk5NhIgIzG0vBIosxCMqJdBxf4yCY,9222
+torchmetrics/retrieval/auroc.py,sha256=r_37wzE7NYsMcW-82UQiDKeHt5Q0bgr52xiqeDBfwqg,7001
+torchmetrics/retrieval/average_precision.py,sha256=JOieRB7hh-oP0Isnazc_UoIbBlKfsK6ixyWjYWJDTqc,6567
+torchmetrics/retrieval/base.py,sha256=Wh5U6kXi0-qSfZyZfWQBt6MKw6OYufZ8-IsRED28FY0,8043
+torchmetrics/retrieval/fall_out.py,sha256=NNbBuhc-nSOxIKfdcoTTr3ABiDI2f2ZaDLA0872c6vE,8186
+torchmetrics/retrieval/hit_rate.py,sha256=yMXY_aMuaTCsnMJADls1rQt6YgjFE56-QeXYnXHGd40,6538
+torchmetrics/retrieval/ndcg.py,sha256=TeT1vWlZ-pdv4PKYEWgff7eqFvOVF3ljfYhgegSdKSM,6664
+torchmetrics/retrieval/precision.py,sha256=E1wFVBNMX4BcYYf0iUxA2Ld3SvnE9WJGPu4Wt4DSoLg,6919
+torchmetrics/retrieval/precision_recall_curve.py,sha256=6z6SMA6SOsox_0gdMwGcp-Kb3uJU7lPgglg4o147TAQ,17893
+torchmetrics/retrieval/r_precision.py,sha256=OV6Q6vyLVjY3nhbyksRD_damTr-a1ljXZq2VlrtkBoU,5627
+torchmetrics/retrieval/recall.py,sha256=-8Xsyxto8e0m8cYuL531PUgjTtwN5U500owDcI5YsBk,6516
+torchmetrics/retrieval/reciprocal_rank.py,sha256=vjee2uUpUXeRt68MsGW8WfwRlO6-bUFM6Ee06LEUMWs,6557
+torchmetrics/segmentation/__init__.py,sha256=3Xht3JWQYpfc3hR8wp-EbxVdTTtm1P9aG6LRz_UoA8c,918
+torchmetrics/segmentation/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/segmentation/__pycache__/dice.cpython-310.pyc,,
+torchmetrics/segmentation/__pycache__/generalized_dice.cpython-310.pyc,,
+torchmetrics/segmentation/__pycache__/hausdorff_distance.cpython-310.pyc,,
+torchmetrics/segmentation/__pycache__/mean_iou.cpython-310.pyc,,
+torchmetrics/segmentation/dice.py,sha256=d_OWYTGajcooqjP7da1hd__Lo-o12ehEU_LEUTlLccM,9079
+torchmetrics/segmentation/generalized_dice.py,sha256=WoKTcjdGyJNhkhvZxSxzKchyDDkyc31jHT3-hyM_Xtc,8423
+torchmetrics/segmentation/hausdorff_distance.py,sha256=PGTJlIcd5lkqI34sZL4nZOeIQGOEHIUM14SY4Gbpwlo,6989
+torchmetrics/segmentation/mean_iou.py,sha256=SbB2u8VCBDLJc-vDpymYQawrjFbi02IjwMGUrtJKTT4,10539
+torchmetrics/shape/__init__.py,sha256=geZDESOmNmoZ_5IZZofbTJlOorwgBqh6liklsX1Q-0k,675
+torchmetrics/shape/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/shape/__pycache__/procrustes.cpython-310.pyc,,
+torchmetrics/shape/procrustes.py,sha256=vO6at_AV6d2GV1hrsqyxQ4O5-NcLDJ0HTiQmmJBl9MI,5734
+torchmetrics/text/__init__.py,sha256=5VeA0U0_AF-00-kP-G-PyVDOjnxnsTkgjZu4FI_oBUk,1819
+torchmetrics/text/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/text/__pycache__/_deprecated.cpython-310.pyc,,
+torchmetrics/text/__pycache__/bert.cpython-310.pyc,,
+torchmetrics/text/__pycache__/bleu.cpython-310.pyc,,
+torchmetrics/text/__pycache__/cer.cpython-310.pyc,,
+torchmetrics/text/__pycache__/chrf.cpython-310.pyc,,
+torchmetrics/text/__pycache__/edit.cpython-310.pyc,,
+torchmetrics/text/__pycache__/eed.cpython-310.pyc,,
+torchmetrics/text/__pycache__/infolm.cpython-310.pyc,,
+torchmetrics/text/__pycache__/mer.cpython-310.pyc,,
+torchmetrics/text/__pycache__/perplexity.cpython-310.pyc,,
+torchmetrics/text/__pycache__/rouge.cpython-310.pyc,,
+torchmetrics/text/__pycache__/sacre_bleu.cpython-310.pyc,,
+torchmetrics/text/__pycache__/squad.cpython-310.pyc,,
+torchmetrics/text/__pycache__/ter.cpython-310.pyc,,
+torchmetrics/text/__pycache__/wer.cpython-310.pyc,,
+torchmetrics/text/__pycache__/wil.cpython-310.pyc,,
+torchmetrics/text/__pycache__/wip.cpython-310.pyc,,
+torchmetrics/text/_deprecated.py,sha256=HGgPtmnq5_2Zqxi3EqfnXvTXXGi6JA3CZntym2xL0ow,8229
+torchmetrics/text/bert.py,sha256=Y4miLqw_I4YmOrKOWjmSq0ssMuO1K_1AUuz0GEgx8tQ,16684
+torchmetrics/text/bleu.py,sha256=WwkBFYVZ6jjoLltbR-djdy9kPFcgB7gC6qIyy-osY4k,5884
+torchmetrics/text/cer.py,sha256=TWRmAvOz6WqqvPgfFKPVPvM7emBoGhpPnBT03XX6O_k,5307
+torchmetrics/text/chrf.py,sha256=C80Jg4l7lhB3eYTe3FDbny62duohgN10sLZSVHLMzbU,10490
+torchmetrics/text/edit.py,sha256=j1fk-57mcP577vj7H23UfHF7HqW4Rhxj1JsGPFsBnrk,7369
+torchmetrics/text/eed.py,sha256=BRIWrDKYgexoZkd-97nmrTrBiekN4ZQpV_DBPMjbbvQ,6381
+torchmetrics/text/infolm.py,sha256=4HzPIahF7sWJ_Bj8WYME18QRD-xEBTc6gKP1qkitF1E,10949
+torchmetrics/text/mer.py,sha256=Rzq6kea3q2K6Te8TxrE6nj-I4I3pp7uI1yagSHS5JX8,5250
+torchmetrics/text/perplexity.py,sha256=RXaUg75kbwGDUIYeicAx7W49deTT1BJbivdGzXCXnwo,5019
+torchmetrics/text/rouge.py,sha256=H_HHPe-ZQ3PyaDgiBbLYCNy_Di-N_8hw6HxXwAxIzI8,9412
+torchmetrics/text/sacre_bleu.py,sha256=PqGRvq9iGexmipUG9hbIVGBYjmPrwJOdublR7dViA2c,7188
+torchmetrics/text/squad.py,sha256=ebACHcgDciqKlJiJuU6NXAFdVmNaUt9n6YR33OX46PQ,6066
+torchmetrics/text/ter.py,sha256=yLpNLa5F-wW5cExjMtocfg48Md9Qw88_aoxeKAEH0fM,6765
+torchmetrics/text/wer.py,sha256=F_54E-BL68GZw0Ni2cMkfyTqX5_56xj7f23Gab0rhes,5232
+torchmetrics/text/wil.py,sha256=zf0xuWcHt5Vsfw8_sUW-THMviRCesyRGTetBtFfj9rM,5359
+torchmetrics/text/wip.py,sha256=dPR8YiszbJesfti30G8JuyZD0yYeW8t7DbEM-cPEW7o,5380
+torchmetrics/utilities/__init__.py,sha256=NM33fJ7MrGne7df6F4OYY9x59IeIWirkdMU5K9Q2Js4,1205
+torchmetrics/utilities/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/checks.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/compute.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/data.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/distributed.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/enums.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/exceptions.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/imports.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/plot.cpython-310.pyc,,
+torchmetrics/utilities/__pycache__/prints.cpython-310.pyc,,
+torchmetrics/utilities/checks.py,sha256=qbrocKIIILEQN7pmy9jWbKcMbdKBBsyL1Sy1qRHGtLc,12885
+torchmetrics/utilities/compute.py,sha256=bv33DfL4Bn3jsv999p0gvSJThhTXnWFzE0I6E2vi-jg,8319
+torchmetrics/utilities/data.py,sha256=p461ppdb5Jxcdc4bHPx4zf1XqMZxh_xsp9zRh-pi6k4,9071
+torchmetrics/utilities/distributed.py,sha256=88GtCrH_xIqg_odhI7_6vz4O3-El9INdvJjHmY3O7yQ,6146
+torchmetrics/utilities/enums.py,sha256=8i7ivcvC5kh8wB10IJZd5q5KkROodKhcYK0c2lIf2aU,3688
+torchmetrics/utilities/exceptions.py,sha256=VMl06AQRg-CjJnkKfWw_XXe11ajlm2I0XiXCi0knZTM,830
+torchmetrics/utilities/imports.py,sha256=59iPLS8g5oh9xc3Alz5UAznFnQ7j8Bnu1IoJ-jmVlpc,3412
+torchmetrics/utilities/plot.py,sha256=AjWBQlXbxDOIpbVZZ0BdXw--OhgUsptGBNpwtRjsKFk,14461
+torchmetrics/utilities/prints.py,sha256=H0kAnHRILObNdOEglHsFS8G6MCJ4uaumyrdzKhpGVKo,2368
+torchmetrics/video/__init__.py,sha256=t6gSl7eQk8zyIFuwxnx01AtxihVMajDK4cSp-71c-Vg,810
+torchmetrics/video/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/video/__pycache__/vmaf.cpython-310.pyc,,
+torchmetrics/video/vmaf.py,sha256=U8dR_b9jUhgsUIcGnXlQ3D_7437M0RT7WLN_-QpHz80,10016
+torchmetrics/wrappers/__init__.py,sha256=_9AfQDwrHrnm3itZIy7xlw6NB9t6aVLgnIgaGwq4CgQ,1462
+torchmetrics/wrappers/__pycache__/__init__.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/abstract.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/bootstrapping.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/classwise.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/feature_share.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/minmax.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/multioutput.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/multitask.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/running.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/tracker.cpython-310.pyc,,
+torchmetrics/wrappers/__pycache__/transformations.cpython-310.pyc,,
+torchmetrics/wrappers/abstract.py,sha256=W74Qd23mi2qbOaQ6AvfyiZXi3AzEpsFPR5WZOxj_MX4,1855
+torchmetrics/wrappers/bootstrapping.py,sha256=C0ztxgGH2P0k09AzILAgqwx3t0H4lNLbE6zkuB4yDnA,9075
+torchmetrics/wrappers/classwise.py,sha256=saeaD2ZehxWcJH4RATRJ-Ei_soas0Z3oqqAxwyhKt2Q,10520
+torchmetrics/wrappers/feature_share.py,sha256=yVEC15r3qDdT9__5LgQuQe7PCjJcJNd7htXvRU6PJwA,6593
+torchmetrics/wrappers/minmax.py,sha256=D_1EsMeHMZUcfu4qYjzu2PBHj_kAKVFivNymWl38YsU,6262
+torchmetrics/wrappers/multioutput.py,sha256=Z2nUuk8NoYEUDrXxqa4MlESB54Zjl6mW6B-ab3ROogY,9584
+torchmetrics/wrappers/multitask.py,sha256=xIt_8z8LlxdRbhV2EJeacuG8gjuMipeqI7Ekc2qyjTg,18398
+torchmetrics/wrappers/running.py,sha256=K9ZU0eIkOW_fa8YCHiNMK2H_uN91DcTxpM3Gu-OGYZI,8362
+torchmetrics/wrappers/tracker.py,sha256=-OalxU2YI0aXNykoCaK42rAizCQQae0ttPjSC0HVOIY,18135
+torchmetrics/wrappers/transformations.py,sha256=y5THlNsdC1kpfrN9CcxyOd5tNhCc9xBm2ur4qxr1yGE,7083

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics-1.9.0.dist-info/WHEEL

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

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics-1.9.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020-2022 Lightning-AI team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics-1.9.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+torchmetrics

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/image/sam.py

@@ -0,0 +1,121 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.distributed import reduce
+
+
+def _sam_update(preds: Tensor, target: Tensor) -> tuple[Tensor, Tensor]:
+    """Update and returns variables required to compute Spectral Angle Mapper.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+
+    """
+    if preds.dtype != target.dtype:
+        raise TypeError(
+            "Expected `preds` and `target` to have the same data type."
+            f" Got preds: {preds.dtype} and target: {target.dtype}."
+        )
+    _check_same_shape(preds, target)
+    if len(preds.shape) != 4:
+        raise ValueError(
+            f"Expected `preds` and `target` to have BxCxHxW shape. Got preds: {preds.shape} and target: {target.shape}."
+        )
+    if (preds.shape[1] <= 1) or (target.shape[1] <= 1):
+        raise ValueError(
+            "Expected channel dimension of `preds` and `target` to be larger than 1."
+            f" Got preds: {preds.shape[1]} and target: {target.shape[1]}."
+        )
+    return preds, target
+
+
+def _sam_compute(
+    preds: Tensor,
+    target: Tensor,
+    reduction: Literal["elementwise_mean", "sum", "none", None] = "elementwise_mean",
+) -> Tensor:
+    """Compute Spectral Angle Mapper.
+
+    Args:
+        preds: estimated image
+        target: ground truth image
+        reduction: a method to reduce metric score over labels.
+
+            - ``'elementwise_mean'``: takes the mean (default)
+            - ``'sum'``: takes the sum
+            - ``'none'`` or ``None``: no reduction will be applied
+
+    Example:
+        >>> from torch import rand
+        >>> preds = rand([16, 3, 16, 16])
+        >>> target = rand([16, 3, 16, 16])
+        >>> preds, target = _sam_update(preds, target)
+        >>> _sam_compute(preds, target)
+        tensor(0.5914)
+
+    """
+    dot_product = (preds * target).sum(dim=1)
+    preds_norm = preds.norm(dim=1)
+    target_norm = target.norm(dim=1)
+    sam_score = torch.clamp(dot_product / (preds_norm * target_norm), -1, 1).acos()
+    return reduce(sam_score, reduction)
+
+
+def spectral_angle_mapper(
+    preds: Tensor,
+    target: Tensor,
+    reduction: Literal["elementwise_mean", "sum", "none", None] = "elementwise_mean",
+) -> Tensor:
+    """Universal Spectral Angle Mapper.
+
+    Args:
+        preds: estimated image
+        target: ground truth image
+        reduction: a method to reduce metric score over labels.
+
+            - ``'elementwise_mean'``: takes the mean (default)
+            - ``'sum'``: takes the sum
+            - ``'none'`` or ``None``: no reduction will be applied
+
+    Return:
+        Tensor with Spectral Angle Mapper score
+
+    Raises:
+        TypeError:
+            If ``preds`` and ``target`` don't have the same data type.
+        ValueError:
+            If ``preds`` and ``target`` don't have ``BxCxHxW shape``.
+
+    Example:
+        >>> from torch import rand
+        >>> from torchmetrics.functional.image import spectral_angle_mapper
+        >>> preds = rand([16, 3, 16, 16],)
+        >>> target = rand([16, 3, 16, 16])
+        >>> spectral_angle_mapper(preds, target)
+        tensor(0.5914)
+
+    References:
+        [1] Roberta H. Yuhas, Alexander F. H. Goetz and Joe W. Boardman, "Discrimination among semi-arid
+        landscape endmembers using the Spectral Angle Mapper (SAM) algorithm" in PL, Summaries of the Third Annual JPL
+        Airborne Geoscience Workshop, vol. 1, June 1, 1992.
+
+    """
+    preds, target = _sam_update(preds, target)
+    return _sam_compute(preds, target, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/image/scc.py

@@ -0,0 +1,220 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import math
+from typing import Optional, Union
+
+import torch
+from torch import Tensor, tensor
+from torch.nn.functional import conv2d, pad
+from typing_extensions import Literal
+
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.distributed import reduce
+
+
+def _scc_update(preds: Tensor, target: Tensor, hp_filter: Tensor, window_size: int) -> tuple[Tensor, Tensor, Tensor]:
+    """Update and returns variables required to compute Spatial Correlation Coefficient.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        hp_filter: High-pass filter tensor
+        window_size: Local window size integer
+
+    Return:
+        Tuple of (preds, target, hp_filter) tensors
+
+    Raises:
+        ValueError:
+            If ``preds`` and ``target`` have different number of channels
+            If ``preds`` and ``target`` have different shapes
+            If ``preds`` and ``target`` have invalid shapes
+            If ``window_size`` is not a positive integer
+            If ``window_size`` is greater than the size of the image
+
+    """
+    if preds.dtype != target.dtype:
+        target = target.to(preds.dtype)
+    _check_same_shape(preds, target)
+    if preds.ndim not in (3, 4):
+        raise ValueError(
+            "Expected `preds` and `target` to have batch of colored images with BxCxHxW shape"
+            "  or batch of grayscale images of BxHxW shape."
+            f" Got preds: {preds.shape} and target: {target.shape}."
+        )
+
+    if len(preds.shape) == 3:
+        preds = preds.unsqueeze(1)
+        target = target.unsqueeze(1)
+
+    if not window_size > 0:
+        raise ValueError(f"Expected `window_size` to be a positive integer. Got {window_size}.")
+
+    if window_size > preds.size(2) or window_size > preds.size(3):
+        raise ValueError(
+            f"Expected `window_size` to be less than or equal to the size of the image."
+            f" Got window_size: {window_size} and image size: {preds.size(2)}x{preds.size(3)}."
+        )
+
+    preds = preds.to(torch.float32)
+    target = target.to(torch.float32)
+    hp_filter = hp_filter[None, None, :].to(dtype=preds.dtype, device=preds.device)
+    return preds, target, hp_filter
+
+
+def _symmetric_reflect_pad_2d(input_img: Tensor, pad: Union[int, tuple[int, ...]]) -> Tensor:
+    """Applies symmetric padding to the 2D image tensor input using ``reflect`` mode (d c b a | a b c d | d c b a)."""
+    if isinstance(pad, int):
+        pad = (pad, pad, pad, pad)
+    if len(pad) != 4:
+        raise ValueError(f"Expected padding to have length 4, but got {len(pad)}")
+
+    left_pad = input_img[:, :, :, 0 : pad[0]].flip(dims=[3])
+    right_pad = input_img[:, :, :, -pad[1] :].flip(dims=[3])
+    padded = torch.cat([left_pad, input_img, right_pad], dim=3)
+
+    top_pad = padded[:, :, 0 : pad[2], :].flip(dims=[2])
+    bottom_pad = padded[:, :, -pad[3] :, :].flip(dims=[2])
+    return torch.cat([top_pad, padded, bottom_pad], dim=2)
+
+
+def _signal_convolve_2d(input_img: Tensor, kernel: Tensor) -> Tensor:
+    """Applies 2D signal convolution to the input tensor with the given kernel."""
+    left_padding = math.floor((kernel.size(3) - 1) / 2)
+    right_padding = math.ceil((kernel.size(3) - 1) / 2)
+    top_padding = math.floor((kernel.size(2) - 1) / 2)
+    bottom_padding = math.ceil((kernel.size(2) - 1) / 2)
+
+    padded = _symmetric_reflect_pad_2d(input_img, pad=(left_padding, right_padding, top_padding, bottom_padding))
+    kernel = kernel.flip([2, 3])
+    return conv2d(padded, kernel, stride=1, padding=0)
+
+
+def _hp_2d_laplacian(input_img: Tensor, kernel: Tensor) -> Tensor:
+    """Applies 2-D Laplace filter to the input tensor with the given high pass filter."""
+    return _signal_convolve_2d(input_img, kernel) * 2.0
+
+
+def _local_variance_covariance(preds: Tensor, target: Tensor, window: Tensor) -> tuple[Tensor, Tensor, Tensor]:
+    """Computes local variance and covariance of the input tensors."""
+    # This code is inspired by
+    # https://github.com/andrewekhalel/sewar/blob/master/sewar/full_ref.py#L187.
+
+    left_padding = math.ceil((window.size(3) - 1) / 2)
+    right_padding = math.floor((window.size(3) - 1) / 2)
+
+    preds = pad(preds, (left_padding, right_padding, left_padding, right_padding))
+    target = pad(target, (left_padding, right_padding, left_padding, right_padding))
+
+    preds_mean = conv2d(preds, window, stride=1, padding=0)
+    target_mean = conv2d(target, window, stride=1, padding=0)
+
+    preds_var = conv2d(preds**2, window, stride=1, padding=0) - preds_mean**2
+    target_var = conv2d(target**2, window, stride=1, padding=0) - target_mean**2
+    target_preds_cov = conv2d(target * preds, window, stride=1, padding=0) - target_mean * preds_mean
+
+    return preds_var, target_var, target_preds_cov
+
+
+def _scc_per_channel_compute(preds: Tensor, target: Tensor, hp_filter: Tensor, window_size: int) -> Tensor:
+    """Computes per channel Spatial Correlation Coefficient.
+
+    Args:
+        preds: estimated image of Bx1xHxW shape.
+        target: ground truth image of Bx1xHxW shape.
+        hp_filter: 2D high-pass filter.
+        window_size: size of window for local mean calculation.
+
+    Return:
+        Tensor with Spatial Correlation Coefficient score
+
+    """
+    dtype = preds.dtype
+    device = preds.device
+
+    # This code is inspired by
+    # https://github.com/andrewekhalel/sewar/blob/master/sewar/full_ref.py#L187.
+
+    window = torch.ones(size=(1, 1, window_size, window_size), dtype=dtype, device=device) / (window_size**2)
+
+    preds_hp = _hp_2d_laplacian(preds, hp_filter)
+    target_hp = _hp_2d_laplacian(target, hp_filter)
+
+    preds_var, target_var, target_preds_cov = _local_variance_covariance(preds_hp, target_hp, window)
+
+    preds_var[preds_var < 0] = 0
+    target_var[target_var < 0] = 0
+
+    den = torch.sqrt(target_var) * torch.sqrt(preds_var)
+    idx = den == 0
+    den[den == 0] = 1
+    scc = target_preds_cov / den
+    scc[idx] = 0
+    return scc
+
+
+def spatial_correlation_coefficient(
+    preds: Tensor,
+    target: Tensor,
+    hp_filter: Optional[Tensor] = None,
+    window_size: int = 8,
+    reduction: Optional[Literal["mean", "none", None]] = "mean",
+) -> Tensor:
+    """Compute Spatial Correlation Coefficient (SCC_).
+
+    Args:
+        preds: predicted images of shape ``(N,C,H,W)`` or ``(N,H,W)``.
+        target: ground truth images of shape ``(N,C,H,W)`` or ``(N,H,W)``.
+        hp_filter: High-pass filter tensor. default: tensor([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])
+        window_size: Local window size integer. default: 8,
+        reduction: Reduction method for output tensor. If ``None`` or ``"none"``,
+                   returns a tensor with the per sample results. default: ``"mean"``.
+
+    Return:
+        Tensor with scc score
+
+    Example:
+        >>> from torch import randn
+        >>> from torchmetrics.functional.image import spatial_correlation_coefficient as scc
+        >>> x = randn(5, 3, 16, 16)
+        >>> scc(x, x)
+        tensor(1.)
+        >>> x = randn(5, 16, 16)
+        >>> scc(x, x)
+        tensor(1.)
+        >>> x = randn(5, 3, 16, 16)
+        >>> y = randn(5, 3, 16, 16)
+        >>> scc(x, y, reduction="none")
+        tensor([0.0223, 0.0256, 0.0616, 0.0159, 0.0170])
+
+    """
+    if hp_filter is None:
+        hp_filter = tensor([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]])
+    if reduction is None:
+        reduction = "none"
+    if reduction not in ("mean", "none"):
+        raise ValueError(f"Expected reduction to be 'mean' or 'none', but got {reduction}")
+    preds, target, hp_filter = _scc_update(preds, target, hp_filter, window_size)
+
+    per_channel = [
+        _scc_per_channel_compute(
+            preds[:, i, :, :].unsqueeze(1), target[:, i, :, :].unsqueeze(1), hp_filter, window_size
+        )
+        for i in range(preds.size(1))
+    ]
+    if reduction == "none":
+        return torch.mean(torch.cat(per_channel, dim=1), dim=[1, 2, 3])
+    if reduction == "mean":
+        return reduce(torch.cat(per_channel, dim=1), reduction="elementwise_mean")
+    return None

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/image/ssim.py

@@ -0,0 +1,529 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections.abc import Sequence
+from typing import List, Optional, Union
+
+import torch
+from torch import Tensor
+from torch.nn import functional as F  # noqa: N812
+from typing_extensions import Literal
+
+from torchmetrics.functional.image.utils import _gaussian_kernel_2d, _gaussian_kernel_3d, _reflection_pad_3d
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.distributed import reduce
+
+
+def _ssim_check_inputs(preds: Tensor, target: Tensor) -> tuple[Tensor, Tensor]:
+    """Update and returns variables required to compute Structural Similarity Index Measure.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+
+    """
+    if preds.dtype != target.dtype:
+        target = target.to(preds.dtype)
+    _check_same_shape(preds, target)
+    if len(preds.shape) not in (4, 5):
+        raise ValueError(
+            "Expected `preds` and `target` to have BxCxHxW or BxCxDxHxW shape."
+            f" Got preds: {preds.shape} and target: {target.shape}."
+        )
+    return preds, target
+
+
+def _ssim_update(
+    preds: Tensor,
+    target: Tensor,
+    gaussian_kernel: bool = True,
+    sigma: Union[float, Sequence[float]] = 1.5,
+    kernel_size: Union[int, Sequence[int]] = 11,
+    data_range: Optional[Union[float, tuple[float, float]]] = None,
+    k1: float = 0.01,
+    k2: float = 0.03,
+    return_full_image: bool = False,
+    return_contrast_sensitivity: bool = False,
+) -> Union[Tensor, tuple[Tensor, Tensor]]:
+    """Compute Structural Similarity Index Measure.
+
+    Args:
+        preds: estimated image
+        target: ground truth image
+        gaussian_kernel: If true (default), a gaussian kernel is used, if false a uniform kernel is used
+        sigma: Standard deviation of the gaussian kernel, anisotropic kernels are possible.
+            Ignored if a uniform kernel is used
+        kernel_size: the size of the uniform kernel, anisotropic kernels are possible.
+            Ignored if a Gaussian kernel is used
+        data_range: Range of the image. If ``None``, it is determined from the image (max - min)
+        k1: Parameter of SSIM.
+        k2: Parameter of SSIM.
+        return_full_image: If true, the full ``ssim`` image is returned as a second argument.
+            Mutually exclusive with ``return_contrast_sensitivity``
+        return_contrast_sensitivity: If true, the contrast term is returned as a second argument.
+            The luminance term can be obtained with luminance=ssim/contrast
+            Mutually exclusive with ``return_full_image``
+
+    """
+    is_3d = preds.ndim == 5
+
+    if not isinstance(kernel_size, Sequence):
+        kernel_size = 3 * [kernel_size] if is_3d else 2 * [kernel_size]
+    if not isinstance(sigma, Sequence):
+        sigma = 3 * [sigma] if is_3d else 2 * [sigma]
+
+    if len(kernel_size) != len(target.shape) - 2:
+        raise ValueError(
+            f"`kernel_size` has dimension {len(kernel_size)}, but expected to be two less that target dimensionality,"
+            f" which is: {len(target.shape)}"
+        )
+    if len(kernel_size) not in (2, 3):
+        raise ValueError(
+            f"Expected `kernel_size` dimension to be 2 or 3. `kernel_size` dimensionality: {len(kernel_size)}"
+        )
+    if len(sigma) != len(target.shape) - 2:
+        raise ValueError(
+            f"`kernel_size` has dimension {len(kernel_size)}, but expected to be two less that target dimensionality,"
+            f" which is: {len(target.shape)}"
+        )
+    if len(sigma) not in (2, 3):
+        raise ValueError(
+            f"Expected `kernel_size` dimension to be 2 or 3. `kernel_size` dimensionality: {len(kernel_size)}"
+        )
+
+    if return_full_image and return_contrast_sensitivity:
+        raise ValueError("Arguments `return_full_image` and `return_contrast_sensitivity` are mutually exclusive.")
+
+    if any(x % 2 == 0 or x <= 0 for x in kernel_size):
+        raise ValueError(f"Expected `kernel_size` to have odd positive number. Got {kernel_size}.")
+
+    if any(y <= 0 for y in sigma):
+        raise ValueError(f"Expected `sigma` to have positive number. Got {sigma}.")
+
+    if data_range is None:
+        data_range = max(preds.max() - preds.min(), target.max() - target.min())  # type: ignore[call-overload]
+    elif isinstance(data_range, tuple):
+        preds = torch.clamp(preds, min=data_range[0], max=data_range[1])
+        target = torch.clamp(target, min=data_range[0], max=data_range[1])
+        data_range = data_range[1] - data_range[0]
+
+    c1 = pow(k1 * data_range, 2)  # type: ignore[operator]
+    c2 = pow(k2 * data_range, 2)  # type: ignore[operator]
+    device = preds.device
+
+    channel = preds.size(1)
+    dtype = preds.dtype
+    gauss_kernel_size = [int(3.5 * s + 0.5) * 2 + 1 for s in sigma]
+
+    if gaussian_kernel:
+        pad_h = (gauss_kernel_size[0] - 1) // 2
+        pad_w = (gauss_kernel_size[1] - 1) // 2
+    else:
+        pad_h = (kernel_size[0] - 1) // 2
+        pad_w = (kernel_size[1] - 1) // 2
+
+    if is_3d:
+        pad_d = (kernel_size[2] - 1) // 2
+        preds = _reflection_pad_3d(preds, pad_d, pad_w, pad_h)
+        target = _reflection_pad_3d(target, pad_d, pad_w, pad_h)
+        if gaussian_kernel:
+            kernel = _gaussian_kernel_3d(channel, gauss_kernel_size, sigma, dtype, device)
+    else:
+        preds = F.pad(preds, (pad_w, pad_w, pad_h, pad_h), mode="reflect")
+        target = F.pad(target, (pad_w, pad_w, pad_h, pad_h), mode="reflect")
+        if gaussian_kernel:
+            kernel = _gaussian_kernel_2d(channel, gauss_kernel_size, sigma, dtype, device)
+
+    if not gaussian_kernel:
+        kernel = torch.ones((channel, 1, *kernel_size), dtype=dtype, device=device) / torch.prod(
+            torch.tensor(kernel_size, dtype=dtype, device=device)
+        )
+
+    input_list = torch.cat((preds, target, preds * preds, target * target, preds * target))  # (5 * B, C, H, W)
+
+    outputs = F.conv3d(input_list, kernel, groups=channel) if is_3d else F.conv2d(input_list, kernel, groups=channel)
+
+    output_list = outputs.split(preds.shape[0])
+
+    mu_pred_sq = output_list[0].pow(2)
+    mu_target_sq = output_list[1].pow(2)
+    mu_pred_target = output_list[0] * output_list[1]
+
+    # Calculate the variance of the predicted and target images, should be non-negative
+    sigma_pred_sq = torch.clamp(output_list[2] - mu_pred_sq, min=0.0)
+    sigma_target_sq = torch.clamp(output_list[3] - mu_target_sq, min=0.0)
+    sigma_pred_target = output_list[4] - mu_pred_target
+
+    upper = 2 * sigma_pred_target.to(dtype) + c2
+    lower = (sigma_pred_sq + sigma_target_sq).to(dtype) + c2
+
+    ssim_idx_full_image = ((2 * mu_pred_target + c1) * upper) / ((mu_pred_sq + mu_target_sq + c1) * lower)
+
+    if return_contrast_sensitivity:
+        contrast_sensitivity = upper / lower
+        if is_3d:
+            contrast_sensitivity = contrast_sensitivity[..., pad_h:-pad_h, pad_w:-pad_w, pad_d:-pad_d]
+        else:
+            contrast_sensitivity = contrast_sensitivity[..., pad_h:-pad_h, pad_w:-pad_w]
+
+        return ssim_idx_full_image.reshape(ssim_idx_full_image.shape[0], -1).mean(-1), contrast_sensitivity.reshape(
+            contrast_sensitivity.shape[0], -1
+        ).mean(-1)
+
+    if return_full_image:
+        return ssim_idx_full_image.reshape(ssim_idx_full_image.shape[0], -1).mean(-1), ssim_idx_full_image
+
+    return ssim_idx_full_image.reshape(ssim_idx_full_image.shape[0], -1).mean(-1)
+
+
+def _ssim_compute(
+    similarities: Tensor,
+    reduction: Literal["elementwise_mean", "sum", "none", None] = "elementwise_mean",
+) -> Tensor:
+    """Apply the specified reduction to pre-computed structural similarity.
+
+    Args:
+        similarities: per image similarities for a batch of images.
+        reduction: a method to reduce metric score over individual batch scores
+
+                - ``'elementwise_mean'``: takes the mean
+                - ``'sum'``: takes the sum
+                - ``'none'`` or ``None``: no reduction will be applied
+
+    Returns:
+        The reduced SSIM score
+
+    """
+    return reduce(similarities, reduction)
+
+
+def structural_similarity_index_measure(
+    preds: Tensor,
+    target: Tensor,
+    gaussian_kernel: bool = True,
+    sigma: Union[float, Sequence[float]] = 1.5,
+    kernel_size: Union[int, Sequence[int]] = 11,
+    reduction: Literal["elementwise_mean", "sum", "none", None] = "elementwise_mean",
+    data_range: Optional[Union[float, tuple[float, float]]] = None,
+    k1: float = 0.01,
+    k2: float = 0.03,
+    return_full_image: bool = False,
+    return_contrast_sensitivity: bool = False,
+) -> Union[Tensor, tuple[Tensor, Tensor]]:
+    """Compute Structural Similarity Index Measure.
+
+    Args:
+        preds: estimated image
+        target: ground truth image
+        gaussian_kernel: If true (default), a gaussian kernel is used, if false a uniform kernel is used
+        sigma: Standard deviation of the gaussian kernel, anisotropic kernels are possible.
+            Ignored if a uniform kernel is used
+        kernel_size: the size of the uniform kernel, anisotropic kernels are possible.
+            Ignored if a Gaussian kernel is used
+        reduction: a method to reduce metric score over labels.
+
+            - ``'elementwise_mean'``: takes the mean
+            - ``'sum'``: takes the sum
+            - ``'none'`` or ``None``: no reduction will be applied
+
+        data_range:
+            the range of the data. If None, it is determined from the data (max - min). If a tuple is provided then
+            the range is calculated as the difference and input is clamped between the values.
+        k1: Parameter of SSIM.
+        k2: Parameter of SSIM.
+        return_full_image: If true, the full ``ssim`` image is returned as a second argument.
+            Mutually exclusive with ``return_contrast_sensitivity``
+        return_contrast_sensitivity: If true, the constant term is returned as a second argument.
+            The luminance term can be obtained with luminance=ssim/contrast
+            Mutually exclusive with ``return_full_image``
+
+    Return:
+        Tensor with SSIM score
+
+    Raises:
+        TypeError:
+            If ``preds`` and ``target`` don't have the same data type.
+        ValueError:
+            If ``preds`` and ``target`` don't have ``BxCxHxW shape``.
+        ValueError:
+            If the length of ``kernel_size`` or ``sigma`` is not ``2``.
+        ValueError:
+            If one of the elements of ``kernel_size`` is not an ``odd positive number``.
+        ValueError:
+            If one of the elements of ``sigma`` is not a ``positive number``.
+
+    Example:
+        >>> from torchmetrics.functional.image import structural_similarity_index_measure
+        >>> preds = torch.rand([3, 3, 256, 256])
+        >>> target = preds * 0.75
+        >>> structural_similarity_index_measure(preds, target)
+        tensor(0.9219)
+
+    """
+    preds, target = _ssim_check_inputs(preds, target)
+    similarity_pack = _ssim_update(
+        preds,
+        target,
+        gaussian_kernel,
+        sigma,
+        kernel_size,
+        data_range,
+        k1,
+        k2,
+        return_full_image,
+        return_contrast_sensitivity,
+    )
+
+    if isinstance(similarity_pack, tuple):
+        similarity, image = similarity_pack
+        return _ssim_compute(similarity, reduction), image
+
+    similarity = similarity_pack
+    return _ssim_compute(similarity, reduction)
+
+
+def _get_normalized_sim_and_cs(
+    preds: Tensor,
+    target: Tensor,
+    gaussian_kernel: bool = True,
+    sigma: Union[float, Sequence[float]] = 1.5,
+    kernel_size: Union[int, Sequence[int]] = 11,
+    data_range: Optional[Union[float, tuple[float, float]]] = None,
+    k1: float = 0.01,
+    k2: float = 0.03,
+    normalize: Optional[Literal["relu", "simple"]] = None,
+) -> tuple[Tensor, Tensor]:
+    sim, contrast_sensitivity = _ssim_update(
+        preds,
+        target,
+        gaussian_kernel,
+        sigma,
+        kernel_size,
+        data_range,
+        k1,
+        k2,
+        return_contrast_sensitivity=True,
+    )
+    if normalize == "relu":
+        sim = torch.relu(sim)
+        contrast_sensitivity = torch.relu(contrast_sensitivity)
+    return sim, contrast_sensitivity
+
+
+def _multiscale_ssim_update(
+    preds: Tensor,
+    target: Tensor,
+    gaussian_kernel: bool = True,
+    sigma: Union[float, Sequence[float]] = 1.5,
+    kernel_size: Union[int, Sequence[int]] = 11,
+    data_range: Optional[Union[float, tuple[float, float]]] = None,
+    k1: float = 0.01,
+    k2: float = 0.03,
+    betas: Union[tuple[float, float, float, float, float], tuple[float, ...]] = (
+        0.0448,
+        0.2856,
+        0.3001,
+        0.2363,
+        0.1333,
+    ),
+    normalize: Optional[Literal["relu", "simple"]] = None,
+) -> Tensor:
+    """Compute Multi-Scale Structural Similarity Index Measure.
+
+    Adapted from: https://github.com/jorge-pessoa/pytorch-msssim/blob/master/pytorch_msssim/__init__.py.
+
+    Args:
+        preds: estimated image
+        target: ground truth image
+        gaussian_kernel: If true, a gaussian kernel is used, if false a uniform kernel is used
+        sigma: Standard deviation of the gaussian kernel
+        kernel_size: size of the gaussian kernel
+        reduction: a method to reduce metric score over labels.
+
+            - ``'elementwise_mean'``: takes the mean
+            - ``'sum'``: takes the sum
+            - ``'none'`` or ``None``: no reduction will be applied
+
+        data_range: Range of the image. If ``None``, it is determined from the image (max - min)
+        k1: Parameter of structural similarity index measure.
+        k2: Parameter of structural similarity index measure.
+        betas: Exponent parameters for individual similarities and contrastive sensitives returned by different image
+            resolutions.
+        normalize: When MultiScaleSSIM loss is used for training, it is desirable to use normalizes to improve the
+            training stability. This `normalize` argument is out of scope of the original implementation [1], and it is
+            adapted from https://github.com/jorge-pessoa/pytorch-msssim instead.
+
+    Raises:
+        ValueError:
+            If the image height or width is smaller then ``2 ** len(betas)``.
+        ValueError:
+            If the image height is smaller than ``(kernel_size[0] - 1) * max(1, (len(betas) - 1)) ** 2``.
+        ValueError:
+            If the image width is smaller than ``(kernel_size[0] - 1) * max(1, (len(betas) - 1)) ** 2``.
+
+    """
+    mcs_list: List[Tensor] = []
+
+    is_3d = preds.ndim == 5
+
+    if not isinstance(kernel_size, Sequence):
+        kernel_size = 3 * [kernel_size] if is_3d else 2 * [kernel_size]
+    if not isinstance(sigma, Sequence):
+        sigma = 3 * [sigma] if is_3d else 2 * [sigma]
+
+    if preds.size()[-1] < 2 ** len(betas) or preds.size()[-2] < 2 ** len(betas):
+        raise ValueError(
+            f"For a given number of `betas` parameters {len(betas)}, the image height and width dimensions must be"
+            f" larger than or equal to {2 ** len(betas)}."
+        )
+
+    _betas_div = max(1, (len(betas) - 1)) ** 2
+    if preds.size()[-2] // _betas_div <= kernel_size[0] - 1:
+        raise ValueError(
+            f"For a given number of `betas` parameters {len(betas)} and kernel size {kernel_size[0]},"
+            f" the image height must be larger than {(kernel_size[0] - 1) * _betas_div}."
+        )
+    if preds.size()[-1] // _betas_div <= kernel_size[1] - 1:
+        raise ValueError(
+            f"For a given number of `betas` parameters {len(betas)} and kernel size {kernel_size[1]},"
+            f" the image width must be larger than {(kernel_size[1] - 1) * _betas_div}."
+        )
+
+    for _ in range(len(betas)):
+        sim, contrast_sensitivity = _get_normalized_sim_and_cs(
+            preds, target, gaussian_kernel, sigma, kernel_size, data_range, k1, k2, normalize=normalize
+        )
+        mcs_list.append(contrast_sensitivity)
+
+        if len(kernel_size) == 2:
+            preds = F.avg_pool2d(preds, (2, 2))
+            target = F.avg_pool2d(target, (2, 2))
+        elif len(kernel_size) == 3:
+            preds = F.avg_pool3d(preds, (2, 2, 2))
+            target = F.avg_pool3d(target, (2, 2, 2))
+        else:
+            raise ValueError("length of kernel_size is neither 2 nor 3")
+
+    mcs_list[-1] = sim
+    mcs_stack = torch.stack(mcs_list)
+
+    if normalize == "simple":
+        mcs_stack = (mcs_stack + 1) / 2
+
+    betas = torch.tensor(betas, device=mcs_stack.device).view(-1, 1)
+    mcs_weighted = mcs_stack**betas
+    return torch.prod(mcs_weighted, axis=0)  # type: ignore[call-overload]
+
+
+def _multiscale_ssim_compute(
+    mcs_per_image: Tensor,
+    reduction: Literal["elementwise_mean", "sum", "none", None] = "elementwise_mean",
+) -> Tensor:
+    """Apply the specified reduction to pre-computed multi-scale structural similarity.
+
+    Args:
+        mcs_per_image: per image similarities for a batch of images.
+        reduction: a method to reduce metric score over individual batch scores
+
+                - ``'elementwise_mean'``: takes the mean
+                - ``'sum'``: takes the sum
+                - ``'none'`` or ``None``: no reduction will be applied
+
+    Returns:
+        The reduced multi-scale structural similarity
+
+    """
+    return reduce(mcs_per_image, reduction)
+
+
+def multiscale_structural_similarity_index_measure(
+    preds: Tensor,
+    target: Tensor,
+    gaussian_kernel: bool = True,
+    sigma: Union[float, Sequence[float]] = 1.5,
+    kernel_size: Union[int, Sequence[int]] = 11,
+    reduction: Literal["elementwise_mean", "sum", "none", None] = "elementwise_mean",
+    data_range: Optional[Union[float, tuple[float, float]]] = None,
+    k1: float = 0.01,
+    k2: float = 0.03,
+    betas: tuple[float, ...] = (0.0448, 0.2856, 0.3001, 0.2363, 0.1333),
+    normalize: Optional[Literal["relu", "simple"]] = "relu",
+) -> Tensor:
+    """Compute `MultiScaleSSIM`_, Multi-scale Structural Similarity Index Measure.
+
+    This metric is a generalization of Structural Similarity Index Measure by incorporating image details at different
+    resolution scores.
+
+    Args:
+        preds: Predictions from model of shape ``[N, C, H, W]``
+        target: Ground truth values of shape ``[N, C, H, W]``
+        gaussian_kernel: If true, a gaussian kernel is used, if false a uniform kernel is used
+        sigma: Standard deviation of the gaussian kernel
+        kernel_size: size of the gaussian kernel
+        reduction: a method to reduce metric score over labels.
+
+            - ``'elementwise_mean'``: takes the mean
+            - ``'sum'``: takes the sum
+            - ``'none'`` or ``None``: no reduction will be applied
+
+        data_range:
+            the range of the data. If None, it is determined from the data (max - min). If a tuple is provided then
+            the range is calculated as the difference and input is clamped between the values.
+        k1: Parameter of structural similarity index measure.
+        k2: Parameter of structural similarity index measure.
+        betas: Exponent parameters for individual similarities and contrastive sensitivities returned by different image
+            resolutions.
+        normalize: When MultiScaleSSIM loss is used for training, it is desirable to use normalizes to improve the
+            training stability. This `normalize` argument is out of scope of the original implementation [1], and it is
+            adapted from https://github.com/jorge-pessoa/pytorch-msssim instead.
+
+    Return:
+        Tensor with Multi-Scale SSIM score
+
+    Raises:
+        TypeError:
+            If ``preds`` and ``target`` don't have the same data type.
+        ValueError:
+            If ``preds`` and ``target`` don't have ``BxCxHxW shape``.
+        ValueError:
+            If the length of ``kernel_size`` or ``sigma`` is not ``2``.
+        ValueError:
+            If one of the elements of ``kernel_size`` is not an ``odd positive number``.
+        ValueError:
+            If one of the elements of ``sigma`` is not a ``positive number``.
+
+    Example:
+        >>> from torch import rand
+        >>> from torchmetrics.functional.image import multiscale_structural_similarity_index_measure
+        >>> preds = rand([3, 3, 256, 256])
+        >>> target = preds * 0.75
+        >>> multiscale_structural_similarity_index_measure(preds, target, data_range=1.0)
+        tensor(0.9628)
+
+    References:
+        [1] Multi-Scale Structural Similarity For Image Quality Assessment by Zhou Wang, Eero P. Simoncelli and Alan C.
+        Bovik `MultiScaleSSIM`_
+
+    """
+    if not isinstance(betas, tuple):
+        raise ValueError("Argument `betas` is expected to be of a type tuple.")
+    if isinstance(betas, tuple) and not all(isinstance(beta, float) for beta in betas):
+        raise ValueError("Argument `betas` is expected to be a tuple of floats.")
+    if normalize and normalize not in ("relu", "simple"):
+        raise ValueError("Argument `normalize` to be expected either `None` or one of 'relu' or 'simple'")
+
+    preds, target = _ssim_check_inputs(preds, target)
+    mcs_per_image = _multiscale_ssim_update(
+        preds, target, gaussian_kernel, sigma, kernel_size, data_range, k1, k2, betas, normalize
+    )
+    return _multiscale_ssim_compute(mcs_per_image, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/image/tv.py

@@ -0,0 +1,77 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional, Union
+
+from torch import Tensor
+from typing_extensions import Literal
+
+
+def _total_variation_update(img: Tensor) -> tuple[Tensor, int]:
+    """Compute total variation statistics on current batch."""
+    if img.ndim != 4:
+        raise RuntimeError(f"Expected input `img` to be an 4D tensor, but got {img.shape}")
+    diff1 = img[..., 1:, :] - img[..., :-1, :]
+    diff2 = img[..., :, 1:] - img[..., :, :-1]
+
+    res1 = diff1.abs().sum([1, 2, 3])
+    res2 = diff2.abs().sum([1, 2, 3])
+    score = res1 + res2
+    return score, img.shape[0]
+
+
+def _total_variation_compute(
+    score: Tensor, num_elements: Union[int, Tensor], reduction: Optional[Literal["mean", "sum", "none"]]
+) -> Tensor:
+    """Compute final total variation score."""
+    if reduction == "mean":
+        return score.sum() / num_elements
+    if reduction == "sum":
+        return score.sum()
+    if reduction is None or reduction == "none":
+        return score
+    raise ValueError("Expected argument `reduction` to either be 'sum', 'mean', 'none' or None")
+
+
+def total_variation(img: Tensor, reduction: Optional[Literal["mean", "sum", "none"]] = "sum") -> Tensor:
+    """Compute total variation loss.
+
+    Args:
+        img: A `Tensor` of shape `(N, C, H, W)` consisting of images
+        reduction: a method to reduce metric score over samples.
+
+            - ``'mean'``: takes the mean over samples
+            - ``'sum'``: takes the sum over samples
+            - ``None`` or ``'none'``: return the score per sample
+
+    Returns:
+        A loss scalar value containing the total variation
+
+    Raises:
+        ValueError:
+            If ``reduction`` is not one of ``'sum'``, ``'mean'``, ``'none'`` or ``None``
+        RuntimeError:
+            If ``img`` is not 4D tensor
+
+    Example:
+        >>> from torch import rand
+        >>> from torchmetrics.functional.image import total_variation
+        >>> img = rand(5, 3, 28, 28)
+        >>> total_variation(img)
+        tensor(7546.8018)
+
+    """
+    # code adapted from:
+    # from kornia.losses import total_variation as kornia_total_variation
+    score, num_elements = _total_variation_update(img)
+    return _total_variation_compute(score, num_elements, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/image/uqi.py

@@ -0,0 +1,171 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections.abc import Sequence
+from typing import Optional
+
+import torch
+from torch import Tensor, nn
+from typing_extensions import Literal
+
+from torchmetrics.functional.image.utils import _gaussian_kernel_2d
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.distributed import reduce
+
+
+def _uqi_update(preds: Tensor, target: Tensor) -> tuple[Tensor, Tensor]:
+    """Update and returns variables required to compute Universal Image Quality Index.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+
+    """
+    if preds.dtype != target.dtype:
+        raise TypeError(
+            "Expected `preds` and `target` to have the same data type."
+            f" Got preds: {preds.dtype} and target: {target.dtype}."
+        )
+    _check_same_shape(preds, target)
+    if len(preds.shape) != 4:
+        raise ValueError(
+            f"Expected `preds` and `target` to have BxCxHxW shape. Got preds: {preds.shape} and target: {target.shape}."
+        )
+    return preds, target
+
+
+def _uqi_compute(
+    preds: Tensor,
+    target: Tensor,
+    kernel_size: Sequence[int] = (11, 11),
+    sigma: Sequence[float] = (1.5, 1.5),
+    reduction: Optional[Literal["elementwise_mean", "sum", "none"]] = "elementwise_mean",
+) -> Tensor:
+    """Compute Universal Image Quality Index.
+
+    Args:
+        preds: estimated image
+        target: ground truth image
+        kernel_size: size of the gaussian kernel
+        sigma: Standard deviation of the gaussian kernel
+        reduction: a method to reduce metric score over labels.
+
+            - ``'elementwise_mean'``: takes the mean (default)
+            - ``'sum'``: takes the sum
+            - ``'none'`` or ``None``: no reduction will be applied
+
+    Example:
+        >>> preds = torch.rand([16, 1, 16, 16])
+        >>> target = preds * 0.75
+        >>> preds, target = _uqi_update(preds, target)
+        >>> _uqi_compute(preds, target)
+        tensor(0.9216)
+
+    """
+    if len(kernel_size) != 2 or len(sigma) != 2:
+        raise ValueError(
+            "Expected `kernel_size` and `sigma` to have the length of two."
+            f" Got kernel_size: {len(kernel_size)} and sigma: {len(sigma)}."
+        )
+
+    if any(x % 2 == 0 or x <= 0 for x in kernel_size):
+        raise ValueError(f"Expected `kernel_size` to have odd positive number. Got {kernel_size}.")
+
+    if any(y <= 0 for y in sigma):
+        raise ValueError(f"Expected `sigma` to have positive number. Got {sigma}.")
+
+    device = preds.device
+    channel = preds.size(1)
+    dtype = preds.dtype
+    kernel = _gaussian_kernel_2d(channel, kernel_size, sigma, dtype, device)
+    pad_h = (kernel_size[0] - 1) // 2
+    pad_w = (kernel_size[1] - 1) // 2
+
+    preds = nn.functional.pad(preds, (pad_h, pad_h, pad_w, pad_w), mode="reflect")
+    target = nn.functional.pad(target, (pad_h, pad_h, pad_w, pad_w), mode="reflect")
+
+    input_list = torch.cat((preds, target, preds * preds, target * target, preds * target))  # (5 * B, C, H, W)
+    outputs = nn.functional.conv2d(input_list, kernel, groups=channel)
+    output_list = outputs.split(preds.shape[0])
+
+    mu_pred_sq = output_list[0].pow(2)
+    mu_target_sq = output_list[1].pow(2)
+    mu_pred_target = output_list[0] * output_list[1]
+
+    # Calculate the variance of the predicted and target images, should be non-negative
+    sigma_pred_sq = torch.clamp(output_list[2] - mu_pred_sq, min=0.0)
+    sigma_target_sq = torch.clamp(output_list[3] - mu_target_sq, min=0.0)
+    sigma_pred_target = output_list[4] - mu_pred_target
+
+    upper = 2 * sigma_pred_target
+    lower = sigma_pred_sq + sigma_target_sq
+    eps = torch.finfo(sigma_pred_sq.dtype).eps
+    uqi_idx = ((2 * mu_pred_target) * upper) / ((mu_pred_sq + mu_target_sq) * lower + eps)
+    uqi_idx = uqi_idx[..., pad_h:-pad_h, pad_w:-pad_w]
+
+    return reduce(uqi_idx, reduction)
+
+
+def universal_image_quality_index(
+    preds: Tensor,
+    target: Tensor,
+    kernel_size: Sequence[int] = (11, 11),
+    sigma: Sequence[float] = (1.5, 1.5),
+    reduction: Optional[Literal["elementwise_mean", "sum", "none"]] = "elementwise_mean",
+) -> Tensor:
+    """Universal Image Quality Index.
+
+    Args:
+        preds: estimated image
+        target: ground truth image
+        kernel_size: size of the gaussian kernel
+        sigma: Standard deviation of the gaussian kernel
+        reduction: a method to reduce metric score over labels.
+
+            - ``'elementwise_mean'``: takes the mean (default)
+            - ``'sum'``: takes the sum
+            - ``'none'`` or ``None``: no reduction will be applied
+
+    Return:
+        Tensor with UniversalImageQualityIndex score
+
+    Raises:
+        TypeError:
+            If ``preds`` and ``target`` don't have the same data type.
+        ValueError:
+            If ``preds`` and ``target`` don't have ``BxCxHxW shape``.
+        ValueError:
+            If the length of ``kernel_size`` or ``sigma`` is not ``2``.
+        ValueError:
+            If one of the elements of ``kernel_size`` is not an ``odd positive number``.
+        ValueError:
+            If one of the elements of ``sigma`` is not a ``positive number``.
+
+    Example:
+        >>> from torchmetrics.functional.image import universal_image_quality_index
+        >>> preds = torch.rand([16, 1, 16, 16])
+        >>> target = preds * 0.75
+        >>> universal_image_quality_index(preds, target)
+        tensor(0.9216)
+
+    References:
+        [1] Zhou Wang and A. C. Bovik, "A universal image quality index," in IEEE Signal Processing Letters, vol. 9,
+        no. 3, pp. 81-84, March 2002, doi: 10.1109/97.995823.
+
+        [2] Zhou Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image quality assessment: from error visibility
+        to structural similarity," in IEEE Transactions on Image Processing, vol. 13, no. 4, pp. 600-612, April 2004,
+        doi: 10.1109/TIP.2003.819861.
+
+    """
+    preds, target = _uqi_update(preds, target)
+    return _uqi_compute(preds, target, kernel_size, sigma, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/image/utils.py

@@ -0,0 +1,173 @@
+from collections.abc import Sequence
+from typing import Union
+
+import torch
+from torch import Tensor
+from torch.nn import functional as F  # noqa: N812
+
+
+def _gaussian(kernel_size: int, sigma: float, dtype: torch.dtype, device: Union[torch.device, str]) -> Tensor:
+    """Compute 1D gaussian kernel.
+
+    Args:
+        kernel_size: size of the gaussian kernel
+        sigma: Standard deviation of the gaussian kernel
+        dtype: data type of the output tensor
+        device: device of the output tensor
+
+    Example:
+        >>> _gaussian(3, 1, torch.float, 'cpu')
+        tensor([[0.2741, 0.4519, 0.2741]])
+
+    """
+    dist = torch.arange(start=(1 - kernel_size) / 2, end=(1 + kernel_size) / 2, step=1, dtype=dtype, device=device)
+    gauss = torch.exp(-torch.pow(dist / sigma, 2) / 2)
+    return (gauss / gauss.sum()).unsqueeze(dim=0)  # (1, kernel_size)
+
+
+def _gaussian_kernel_2d(
+    channel: int,
+    kernel_size: Sequence[int],
+    sigma: Sequence[float],
+    dtype: torch.dtype,
+    device: Union[torch.device, str],
+) -> Tensor:
+    """Compute 2D gaussian kernel.
+
+    Args:
+        channel: number of channels in the image
+        kernel_size: size of the gaussian kernel as a tuple (h, w)
+        sigma: Standard deviation of the gaussian kernel
+        dtype: data type of the output tensor
+        device: device of the output tensor
+
+    Example:
+        >>> _gaussian_kernel_2d(1, (5,5), (1,1), torch.float, "cpu")
+        tensor([[[[0.0030, 0.0133, 0.0219, 0.0133, 0.0030],
+                  [0.0133, 0.0596, 0.0983, 0.0596, 0.0133],
+                  [0.0219, 0.0983, 0.1621, 0.0983, 0.0219],
+                  [0.0133, 0.0596, 0.0983, 0.0596, 0.0133],
+                  [0.0030, 0.0133, 0.0219, 0.0133, 0.0030]]]])
+
+    """
+    gaussian_kernel_x = _gaussian(kernel_size[0], sigma[0], dtype, device)
+    gaussian_kernel_y = _gaussian(kernel_size[1], sigma[1], dtype, device)
+    kernel = torch.matmul(gaussian_kernel_x.t(), gaussian_kernel_y)  # (kernel_size, 1) * (1, kernel_size)
+
+    return kernel.expand(channel, 1, kernel_size[0], kernel_size[1])
+
+
+def _uniform_weight_bias_conv2d(inputs: Tensor, window_size: int) -> tuple[Tensor, Tensor]:
+    """Construct uniform weight and bias for a 2d convolution.
+
+    Args:
+        inputs: Input image
+        window_size: size of convolutional kernel
+
+    Return:
+        The weight and bias for 2d convolution
+
+    """
+    kernel_weight = torch.ones(1, 1, window_size, window_size, dtype=inputs.dtype, device=inputs.device)
+    kernel_weight /= window_size**2
+    kernel_bias = torch.zeros(1, dtype=inputs.dtype, device=inputs.device)
+    return kernel_weight, kernel_bias
+
+
+def _single_dimension_pad(inputs: Tensor, dim: int, pad: int, outer_pad: int = 0) -> Tensor:
+    """Apply single-dimension reflection padding to match scipy implementation.
+
+    Args:
+        inputs: Input image
+        dim: A dimension the image should be padded over
+        pad: Number of pads
+        outer_pad: Number of outer pads
+
+    Return:
+        Image padded over a single dimension
+
+    """
+    _max = inputs.shape[dim]
+    x = torch.index_select(inputs, dim, torch.arange(pad - 1, -1, -1).to(inputs.device))
+    y = torch.index_select(inputs, dim, torch.arange(_max - 1, _max - pad - outer_pad, -1).to(inputs.device))
+    return torch.cat((x, inputs, y), dim)
+
+
+def _reflection_pad_2d(inputs: Tensor, pad: int, outer_pad: int = 0) -> Tensor:
+    """Apply reflection padding to the input image.
+
+    Args:
+        inputs: Input image
+        pad: Number of pads
+        outer_pad: Number of outer pads
+
+    Return:
+        Padded image
+
+    """
+    for dim in [2, 3]:
+        inputs = _single_dimension_pad(inputs, dim, pad, outer_pad)
+    return inputs
+
+
+def _uniform_filter(inputs: Tensor, window_size: int) -> Tensor:
+    """Apply uniform filter with a window of a given size over the input image.
+
+    Args:
+        inputs: Input image
+        window_size: Sliding window used for rmse calculation
+
+    Return:
+        Image transformed with the uniform input
+
+    """
+    inputs = _reflection_pad_2d(inputs, window_size // 2, window_size % 2)
+    kernel_weight, kernel_bias = _uniform_weight_bias_conv2d(inputs, window_size)
+    # Iterate over channels
+    return torch.cat(
+        [
+            F.conv2d(inputs[:, channel].unsqueeze(1), kernel_weight, kernel_bias, padding=0)
+            for channel in range(inputs.shape[1])
+        ],
+        dim=1,
+    )
+
+
+def _gaussian_kernel_3d(
+    channel: int, kernel_size: Sequence[int], sigma: Sequence[float], dtype: torch.dtype, device: torch.device
+) -> Tensor:
+    """Compute 3D gaussian kernel.
+
+    Args:
+        channel: number of channels in the image
+        kernel_size: size of the gaussian kernel as a tuple (h, w, d)
+        sigma: Standard deviation of the gaussian kernel
+        dtype: data type of the output tensor
+        device: device of the output tensor
+
+    """
+    gaussian_kernel_x = _gaussian(kernel_size[0], sigma[0], dtype, device)
+    gaussian_kernel_y = _gaussian(kernel_size[1], sigma[1], dtype, device)
+    gaussian_kernel_z = _gaussian(kernel_size[2], sigma[2], dtype, device)
+    kernel_xy = torch.matmul(gaussian_kernel_x.t(), gaussian_kernel_y)  # (kernel_size, 1) * (1, kernel_size)
+    kernel = torch.mul(
+        kernel_xy.unsqueeze(-1).repeat(1, 1, kernel_size[2]),
+        gaussian_kernel_z.expand(kernel_size[0], kernel_size[1], kernel_size[2]),
+    )
+    return kernel.expand(channel, 1, kernel_size[0], kernel_size[1], kernel_size[2])
+
+
+def _reflection_pad_3d(inputs: Tensor, pad_h: int, pad_w: int, pad_d: int) -> Tensor:
+    """Reflective padding of 3d input.
+
+    Args:
+        inputs: tensor to pad, should be a 3D tensor of shape ``[N, C, H, W, D]``
+        pad_w: amount of padding in the height dimension
+        pad_h: amount of padding in the width dimension
+        pad_d: amount of padding in the depth dimension
+
+    Returns:
+        padded input tensor
+
+    """
+    return F.pad(inputs, (pad_h, pad_h, pad_w, pad_w, pad_d, pad_d), mode="reflect")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/image/vif.py

@@ -0,0 +1,154 @@
+# Copyright The PyTorch Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+from torch import Tensor
+from torch.nn.functional import conv2d
+from typing_extensions import Literal
+
+from torchmetrics.utilities.data import dim_zero_cat
+
+
+def _filter(win_size: float, sigma: float, dtype: torch.dtype, device: torch.device) -> Tensor:
+    # This code is inspired by
+    # https://github.com/andrewekhalel/sewar/blob/ac76e7bc75732fde40bb0d3908f4b6863400cc27/sewar/utils.py#L45
+    # https://github.com/photosynthesis-team/piq/blob/01e16b7d8c76bc8765fb6a69560d806148b8046a/piq/functional/filters.py#L38
+    # Both links do the same, but the second one is cleaner
+    coords = torch.arange(win_size, dtype=dtype, device=device) - (win_size - 1) / 2
+    g = coords**2
+    g = torch.exp(-(g.unsqueeze(0) + g.unsqueeze(1)) / (2.0 * sigma**2))
+    g /= torch.sum(g)
+    return g
+
+
+def _vif_per_channel(preds: Tensor, target: Tensor, sigma_n_sq: float) -> Tensor:
+    dtype = preds.dtype
+    device = preds.device
+
+    preds = preds.unsqueeze(1)  # Add channel dimension
+    target = target.unsqueeze(1)
+    # Constant for numerical stability
+    eps = torch.tensor(1e-10, dtype=dtype, device=device)
+
+    sigma_n_sq = torch.tensor(sigma_n_sq, dtype=dtype, device=device)
+
+    preds_vif = torch.zeros(preds.size(0), dtype=dtype, device=device)
+    target_vif = torch.zeros(preds.size(0), dtype=dtype, device=device)
+
+    for scale in range(4):
+        n = 2.0 ** (4 - scale) + 1
+        kernel = _filter(n, n / 5, dtype=dtype, device=device)[None, None, :]
+
+        if scale > 0:
+            target = conv2d(target, kernel)[:, :, ::2, ::2]
+            preds = conv2d(preds, kernel)[:, :, ::2, ::2]
+
+        mu_target = conv2d(target, kernel)
+        mu_preds = conv2d(preds, kernel)
+        mu_target_sq = mu_target**2
+        mu_preds_sq = mu_preds**2
+        mu_target_preds = mu_target * mu_preds
+
+        sigma_target_sq = torch.clamp(conv2d(target**2, kernel) - mu_target_sq, min=0.0)
+        sigma_preds_sq = torch.clamp(conv2d(preds**2, kernel) - mu_preds_sq, min=0.0)
+        sigma_target_preds = conv2d(target * preds, kernel) - mu_target_preds
+
+        g = sigma_target_preds / (sigma_target_sq + eps)
+        sigma_v_sq = sigma_preds_sq - g * sigma_target_preds
+
+        mask = sigma_target_sq < eps
+        g[mask] = 0
+        sigma_v_sq[mask] = sigma_preds_sq[mask]
+        sigma_target_sq[mask] = 0
+
+        mask = sigma_preds_sq < eps
+        g[mask] = 0
+        sigma_v_sq[mask] = 0
+
+        mask = g < 0
+        sigma_v_sq[mask] = sigma_preds_sq[mask]
+        g[mask] = 0
+        sigma_v_sq = torch.clamp(sigma_v_sq, min=eps)
+
+        preds_vif += torch.sum(torch.log10(1.0 + (g**2.0) * sigma_target_sq / (sigma_v_sq + sigma_n_sq)), dim=[1, 2, 3])
+        target_vif += torch.sum(torch.log10(1.0 + sigma_target_sq / sigma_n_sq), dim=[1, 2, 3])
+
+    return preds_vif / target_vif
+
+
+def visual_information_fidelity(
+    preds: Tensor,
+    target: Tensor,
+    sigma_n_sq: float = 2.0,
+    reduction: Literal["mean", "none"] = "mean",
+) -> Tensor:
+    """Compute Pixel-Based Visual Information Fidelity (VIF-P).
+
+    VIF is a full-reference metric that measures the amount of visual information
+    preserved in a distorted image compared to the reference image.
+
+    Args:
+        preds: Predicted images of shape (N, C, H, W). Height and width must be at least 41.
+        target: Ground truth images of shape (N, C, H, W). Must match preds in shape.
+        sigma_n_sq: Variance of the visual noise. Default: 2.0.
+        reduction: Method for reducing the metric across the batch.
+            - "mean": Return a tensor average over the batch.
+            - "none": Return a VIF score for each sample as a 1D tensor of shape (N,).
+
+    Returns:
+        torch.Tensor: VIF score(s). The shape depends on the `reduction` argument:
+            - If ``reduction="mean"``, returns a scalar tensor.
+            - If ``reduction="none"``, returns a tensor of shape ``(N,)``.
+
+    Raises:
+        ValueError: If input dimensions are smaller than ``41x41``.
+        ValueError: If ``preds`` and ``target`` shapes don't match.
+        ValueError: If ``reduction`` is not ``"mean"`` or ``"none"``.
+
+    Example:
+        >>> from torchmetrics.functional.image import visual_information_fidelity
+        >>> preds = torch.randn(4, 3, 41, 41, generator=torch.Generator().manual_seed(42))
+        >>> target = torch.randn(4, 3, 41, 41, generator=torch.Generator().manual_seed(43))
+        >>> visual_information_fidelity(preds, target, reduction="none")
+        tensor([0.0040, 0.0049, 0.0017, 0.0039])
+
+    """
+    # This code is inspired by
+    # https://github.com/photosynthesis-team/piq/blob/01e16b7d8c76bc8765fb6a69560d806148b8046a/piq/vif.py and
+    # https://github.com/andrewekhalel/sewar/blob/ac76e7bc75732fde40bb0d3908f4b6863400cc27/sewar/full_ref.py#L357.
+
+    if preds.size(-1) < 41 or preds.size(-2) < 41:
+        raise ValueError(f"Invalid size of preds. Expected at least 41x41, but got {preds.size(-1)}x{preds.size(-2)}!")
+
+    if target.size(-1) < 41 or target.size(-2) < 41:
+        raise ValueError(
+            f"Invalid size of target. Expected at least 41x41, but got {target.size(-1)}x{target.size(-2)}!"
+        )
+
+    if preds.shape != target.shape:
+        raise ValueError(f"`preds` and `target` must have the same shape, but got {preds.shape} vs {target.shape}.")
+
+    if reduction not in ("mean", "none"):
+        raise ValueError(f"Argument `reduction` must be 'mean' or 'none', but got {reduction}")
+
+    per_channel_scores = [
+        _vif_per_channel(preds[:, i, :, :], target[:, i, :, :], sigma_n_sq) for i in range(preds.size(1))
+    ]
+
+    vif_per_sample = dim_zero_cat(
+        torch.stack(per_channel_scores, dim=0).mean(0) if preds.size(1) > 1 else per_channel_scores[0]
+    )
+
+    if reduction == "mean":
+        return vif_per_sample.mean()
+    return vif_per_sample

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/multimodal/__init__.py

@@ -0,0 +1,23 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from torchmetrics.functional.multimodal.lve import lip_vertex_error
+from torchmetrics.utilities.imports import _TRANSFORMERS_GREATER_EQUAL_4_10
+
+__all__ = ["lip_vertex_error"]
+
+if _TRANSFORMERS_GREATER_EQUAL_4_10:
+    from torchmetrics.functional.multimodal.clip_iqa import clip_image_quality_assessment
+    from torchmetrics.functional.multimodal.clip_score import clip_score
+
+    __all__ += ["clip_image_quality_assessment", "clip_score"]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/multimodal/clip_iqa.py

@@ -0,0 +1,350 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING, Literal, Union
+
+import torch
+from torch import Tensor
+
+from torchmetrics.functional.multimodal.clip_score import _get_clip_model_and_processor
+from torchmetrics.utilities.checks import _SKIP_SLOW_DOCTEST, _try_proceed_with_timeout
+from torchmetrics.utilities.imports import _PIQ_GREATER_EQUAL_0_8, _TRANSFORMERS_GREATER_EQUAL_4_10
+
+if TYPE_CHECKING:
+    from transformers import CLIPModel as _CLIPModel
+    from transformers import CLIPProcessor as _CLIPProcessor
+
+if _SKIP_SLOW_DOCTEST and _TRANSFORMERS_GREATER_EQUAL_4_10:
+    from transformers import CLIPModel as _CLIPModel
+    from transformers import CLIPProcessor as _CLIPProcessor
+
+    def _download_clip_for_iqa_metric() -> None:
+        _CLIPModel.from_pretrained("openai/clip-vit-base-patch16", resume_download=True)
+        _CLIPProcessor.from_pretrained("openai/clip-vit-base-patch16", resume_download=True)
+
+    if not _try_proceed_with_timeout(_download_clip_for_iqa_metric):
+        __doctest_skip__ = ["clip_image_quality_assessment"]
+else:
+    __doctest_skip__ = ["clip_image_quality_assessment"]
+
+if not _PIQ_GREATER_EQUAL_0_8:
+    __doctest_skip__ = ["clip_image_quality_assessment"]
+
+_PROMPTS: dict[str, tuple[str, str]] = {
+    "quality": ("Good photo.", "Bad photo."),
+    "brightness": ("Bright photo.", "Dark photo."),
+    "noisiness": ("Clean photo.", "Noisy photo."),
+    "colorfullness": ("Colorful photo.", "Dull photo."),
+    "sharpness": ("Sharp photo.", "Blurry photo."),
+    "contrast": ("High contrast photo.", "Low contrast photo."),
+    "complexity": ("Complex photo.", "Simple photo."),
+    "natural": ("Natural photo.", "Synthetic photo."),
+    "happy": ("Happy photo.", "Sad photo."),
+    "scary": ("Scary photo.", "Peaceful photo."),
+    "new": ("New photo.", "Old photo."),
+    "warm": ("Warm photo.", "Cold photo."),
+    "real": ("Real photo.", "Abstract photo."),
+    "beautiful": ("Beautiful photo.", "Ugly photo."),
+    "lonely": ("Lonely photo.", "Sociable photo."),
+    "relaxing": ("Relaxing photo.", "Stressful photo."),
+}
+
+
+def _get_clip_iqa_model_and_processor(
+    model_name_or_path: Literal[
+        "clip_iqa",
+        "openai/clip-vit-base-patch16",
+        "openai/clip-vit-base-patch32",
+        "openai/clip-vit-large-patch14-336",
+        "openai/clip-vit-large-patch14",
+    ],
+) -> tuple["_CLIPModel", "_CLIPProcessor"]:
+    """Extract the CLIP model and processor from the model name or path."""
+    from transformers import CLIPProcessor as _CLIPProcessor
+
+    if model_name_or_path == "clip_iqa":
+        if not _PIQ_GREATER_EQUAL_0_8:
+            raise ValueError(
+                "For metric `clip_iqa` to work with argument `model_name_or_path` set to default value `'clip_iqa'`"
+                ", package `piq` version v0.8.0 or later must be installed. Either install with `pip install piq` or"
+                "`pip install torchmetrics[multimodal]`"
+            )
+
+        import piq
+
+        model = piq.clip_iqa.clip.load().eval()
+        # any model checkpoint can be used here because the tokenizer is the same for all
+        processor = _CLIPProcessor.from_pretrained("openai/clip-vit-base-patch16")
+        return model, processor
+    return _get_clip_model_and_processor(model_name_or_path)
+
+
+def _clip_iqa_format_prompts(
+    prompts: tuple[Union[str, tuple[str, str]], ...] = ("quality",),
+) -> tuple[list[str], list[str]]:
+    """Converts the provided keywords into a list of prompts for the model to calculate the anchor vectors.
+
+    Args:
+        prompts: A string, tuple of strings or nested tuple of strings. If a single string is provided, it must be one
+            of the available prompts (see above). Else the input is expected to be a tuple, where each element can
+            be one of two things: either a string or a tuple of strings. If a string is provided, it must be one of the
+            available prompts (see above). If tuple is provided, it must be of length 2 and the first string must be a
+            positive prompt and the second string must be a negative prompt.
+
+    Returns:
+        Tuple containing a list of prompts and a list of the names of the prompts. The first list is double the length
+        of the second list.
+
+    Examples::
+
+        >>> # single prompt
+        >>> _clip_iqa_format_prompts(("quality",))
+        (['Good photo.', 'Bad photo.'], ['quality'])
+        >>> # multiple prompts
+        >>> _clip_iqa_format_prompts(("quality", "brightness"))
+        (['Good photo.', 'Bad photo.', 'Bright photo.', 'Dark photo.'], ['quality', 'brightness'])
+        >>> # Custom prompts
+        >>> _clip_iqa_format_prompts(("quality", ("Super good photo.", "Super bad photo.")))
+        (['Good photo.', 'Bad photo.', 'Super good photo.', 'Super bad photo.'], ['quality', 'user_defined_0'])
+
+    """
+    if not isinstance(prompts, tuple):
+        raise ValueError("Argument `prompts` must be a tuple containing strings or tuples of strings")
+
+    prompts_names: list[str] = []
+    prompts_list: list[str] = []
+    count = 0
+    for p in prompts:
+        if not isinstance(p, (str, tuple)):
+            raise ValueError("Argument `prompts` must be a tuple containing strings or tuples of strings")
+        if isinstance(p, str):
+            if p not in _PROMPTS:
+                raise ValueError(
+                    f"All elements of `prompts` must be one of {_PROMPTS.keys()} if not custom tuple prompts, got {p}."
+                )
+            prompts_names.append(p)
+            prompts_list.extend(_PROMPTS[p])
+        if isinstance(p, tuple) and len(p) != 2:
+            raise ValueError("If a tuple is provided in argument `prompts`, it must be of length 2")
+        if isinstance(p, tuple):
+            prompts_names.append(f"user_defined_{count}")
+            prompts_list.extend(p)
+            count += 1
+
+    return prompts_list, prompts_names
+
+
+def _clip_iqa_get_anchor_vectors(
+    model_name_or_path: str,
+    model: "_CLIPModel",
+    processor: "_CLIPProcessor",
+    prompts_list: list[str],
+    device: Union[str, torch.device],
+) -> Tensor:
+    """Calculates the anchor vectors for the CLIP IQA metric.
+
+    Args:
+        model_name_or_path: string indicating the version of the CLIP model to use.
+        model: The CLIP model
+        processor: The CLIP processor
+        prompts_list: A list of prompts
+        device: The device to use for the calculation
+
+    """
+    if model_name_or_path == "clip_iqa":
+        text_processed = processor(text=prompts_list)
+        anchors_text = torch.zeros(
+            len(prompts_list), processor.tokenizer.model_max_length, dtype=torch.long, device=device
+        )
+        for i, tp in enumerate(text_processed["input_ids"]):
+            anchors_text[i, : len(tp)] = torch.tensor(tp, dtype=torch.long, device=device)
+
+        anchors = model.encode_text(anchors_text).float()
+    else:
+        text_processed = processor(text=prompts_list, return_tensors="pt", padding=True)
+        anchors = model.get_text_features(
+            text_processed["input_ids"].to(device), text_processed["attention_mask"].to(device)
+        )
+    return anchors / anchors.norm(p=2, dim=-1, keepdim=True)
+
+
+def _clip_iqa_update(
+    model_name_or_path: str,
+    images: Tensor,
+    model: "_CLIPModel",
+    processor: "_CLIPProcessor",
+    data_range: float,
+    device: Union[str, torch.device],
+) -> Tensor:
+    images = images / float(data_range)
+    """Update function for CLIP IQA."""
+    if model_name_or_path == "clip_iqa":
+        # default mean and std from clip paper, see:
+        # https://github.com/huggingface/transformers/blob/main/src/transformers/utils/constants.py
+        default_mean = torch.tensor([0.48145466, 0.4578275, 0.40821073], device=device).view(1, 3, 1, 1)
+        default_std = torch.tensor([0.26862954, 0.26130258, 0.27577711], device=device).view(1, 3, 1, 1)
+        images = (images - default_mean) / default_std
+        img_features = model.encode_image(images.float(), pos_embedding=False).float()
+    else:
+        processed_input = processor(images=[i.cpu() for i in images], return_tensors="pt", padding=True)
+        img_features = model.get_image_features(processed_input["pixel_values"].to(device))
+    return img_features / img_features.norm(p=2, dim=-1, keepdim=True)
+
+
+def _clip_iqa_compute(
+    img_features: Tensor,
+    anchors: Tensor,
+    prompts_names: list[str],
+    format_as_dict: bool = True,
+) -> Union[Tensor, dict[str, Tensor]]:
+    """Final computation of CLIP IQA."""
+    logits_per_image = 100 * img_features @ anchors.t()
+    probs = logits_per_image.reshape(logits_per_image.shape[0], -1, 2).softmax(-1)[:, :, 0]
+    if len(prompts_names) == 1:
+        return probs.squeeze()
+    if format_as_dict:
+        return {p: probs[:, i] for i, p in enumerate(prompts_names)}
+    return probs
+
+
+def clip_image_quality_assessment(
+    images: Tensor,
+    model_name_or_path: Literal[
+        "clip_iqa",
+        "openai/clip-vit-base-patch16",
+        "openai/clip-vit-base-patch32",
+        "openai/clip-vit-large-patch14-336",
+        "openai/clip-vit-large-patch14",
+    ] = "clip_iqa",
+    data_range: float = 1.0,
+    prompts: tuple[Union[str, tuple[str, str]], ...] = ("quality",),
+) -> Union[Tensor, dict[str, Tensor]]:
+    """Calculates `CLIP-IQA`_, that can be used to measure the visual content of images.
+
+    The metric is based on the `CLIP`_ model, which is a neural network trained on a variety of (image, text) pairs to
+    be able to generate a vector representation of the image and the text that is similar if the image and text are
+    semantically similar.
+
+    The metric works by calculating the cosine similarity between user provided images and pre-defined prompts. The
+    prompts always come in pairs of "positive" and "negative" such as "Good photo." and "Bad photo.". By calculating
+    the similartity between image embeddings and both the "positive" and "negative" prompt, the metric can determine
+    which prompt the image is more similar to. The metric then returns the probability that the image is more similar
+    to the first prompt than the second prompt.
+
+    Build in prompts are:
+        * quality: "Good photo." vs "Bad photo."
+        * brightness: "Bright photo." vs "Dark photo."
+        * noisiness: "Clean photo." vs "Noisy photo."
+        * colorfullness: "Colorful photo." vs "Dull photo."
+        * sharpness: "Sharp photo." vs "Blurry photo."
+        * contrast: "High contrast photo." vs "Low contrast photo."
+        * complexity: "Complex photo." vs "Simple photo."
+        * natural: "Natural photo." vs "Synthetic photo."
+        * happy: "Happy photo." vs "Sad photo."
+        * scary: "Scary photo." vs "Peaceful photo."
+        * new: "New photo." vs "Old photo."
+        * warm: "Warm photo." vs "Cold photo."
+        * real: "Real photo." vs "Abstract photo."
+        * beautiful: "Beautiful photo." vs "Ugly photo."
+        * lonely: "Lonely photo." vs "Sociable photo."
+        * relaxing: "Relaxing photo." vs "Stressful photo."
+
+    Args:
+        images: Either a single ``[N, C, H, W]`` tensor or a list of ``[C, H, W]`` tensors
+        model_name_or_path: string indicating the version of the CLIP model to use. By default this argument is set to
+            ``clip_iqa`` which corresponds to the model used in the original paper. Other available models are
+            `"openai/clip-vit-base-patch16"`, `"openai/clip-vit-base-patch32"`, `"openai/clip-vit-large-patch14-336"`
+            and `"openai/clip-vit-large-patch14"`
+        data_range: The maximum value of the input tensor. For example, if the input images are in range [0, 255],
+            data_range should be 255. The images are normalized by this value.
+        prompts: A string, tuple of strings or nested tuple of strings. If a single string is provided, it must be one
+            of the available prompts (see above). Else the input is expected to be a tuple, where each element can
+            be one of two things: either a string or a tuple of strings. If a string is provided, it must be one of the
+            available prompts (see above). If tuple is provided, it must be of length 2 and the first string must be a
+            positive prompt and the second string must be a negative prompt.
+
+    .. hint::
+        If using the default `clip_iqa` model, the package `piq` must be installed. Either install with
+        `pip install piq` or `pip install torchmetrics[multimodal]`.
+
+    Returns:
+        A tensor of shape ``(N,)`` if a single prompts is provided. If a list of prompts is provided, a dictionary of
+        with the prompts as keys and tensors of shape ``(N,)`` as values.
+
+    Raises:
+        ModuleNotFoundError:
+            If transformers package is not installed or version is lower than 4.10.0
+        ValueError:
+            If not all images have format [C, H, W]
+        ValueError:
+            If prompts is a tuple and it is not of length 2
+        ValueError:
+            If prompts is a string and it is not one of the available prompts
+        ValueError:
+            If prompts is a list of strings and not all strings are one of the available prompts
+
+    Example::
+        Single prompt:
+
+        >>> from torch import randint
+        >>> from torchmetrics.functional.multimodal import clip_image_quality_assessment
+        >>> imgs = randint(255, (2, 3, 224, 224)).float()
+        >>> clip_image_quality_assessment(imgs, prompts=("quality",))
+        tensor([0.8894, 0.8902])
+
+    Example::
+        Multiple prompts:
+
+        >>> from torch import randint
+        >>> from torchmetrics.functional.multimodal import clip_image_quality_assessment
+        >>> imgs = randint(255, (2, 3, 224, 224)).float()
+        >>> clip_image_quality_assessment(imgs, prompts=("quality", "brightness"))
+        {'quality': tensor([0.8693, 0.8705]), 'brightness': tensor([0.5722, 0.4762])}
+
+    Example::
+        Custom prompts. Must always be a tuple of length 2, with a positive and negative prompt.
+
+        >>> from torch import rand
+        >>> from torchmetrics.functional.multimodal import clip_image_quality_assessment
+        >>> imgs = randint(255, (2, 3, 224, 224)).float()
+        >>> clip_image_quality_assessment(imgs, prompts=(("Super good photo.", "Super bad photo."), "brightness"))
+        {'user_defined_0': tensor([0.9578, 0.9654]), 'brightness': tensor([0.5495, 0.5764])}
+
+    """
+    prompts_list, prompts_names = _clip_iqa_format_prompts(prompts)
+
+    model, processor = _get_clip_iqa_model_and_processor(model_name_or_path)
+    device = images.device
+    model = model.to(device)
+
+    with torch.inference_mode():
+        anchors = _clip_iqa_get_anchor_vectors(model_name_or_path, model, processor, prompts_list, device)
+        img_features = _clip_iqa_update(model_name_or_path, images, model, processor, data_range, device)
+        return _clip_iqa_compute(img_features, anchors, prompts_names)
+
+
+if TYPE_CHECKING:
+    from functools import partial
+    from typing import Any, cast
+
+    images = cast(Any, None)
+
+    f = partial(clip_image_quality_assessment, images=images)
+    f(prompts=("colorfullness",))
+    f(
+        prompts=("quality", "brightness", "noisiness"),
+    )
+    f(
+        prompts=("quality", "brightness", "noisiness", "colorfullness"),
+    )
+    f(prompts=(("Photo of a cat", "Photo of a dog"), "quality", ("Colorful photo", "Black and white photo")))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/multimodal/clip_score.py

@@ -0,0 +1,354 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING, Any, Callable, List, Union, cast
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.utilities import rank_zero_warn
+from torchmetrics.utilities.checks import _SKIP_SLOW_DOCTEST, _try_proceed_with_timeout
+from torchmetrics.utilities.imports import _TRANSFORMERS_GREATER_EQUAL_4_10
+
+if TYPE_CHECKING and _TRANSFORMERS_GREATER_EQUAL_4_10:
+    from transformers import CLIPModel as _CLIPModel
+    from transformers import CLIPProcessor as _CLIPProcessor
+
+if _SKIP_SLOW_DOCTEST and _TRANSFORMERS_GREATER_EQUAL_4_10:
+    from transformers import CLIPModel as _CLIPModel
+    from transformers import CLIPProcessor as _CLIPProcessor
+
+    def _download_clip_for_clip_score() -> None:
+        _CLIPModel.from_pretrained("openai/clip-vit-large-patch14", resume_download=True)
+        _CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14", resume_download=True)
+
+    if not _try_proceed_with_timeout(_download_clip_for_clip_score):
+        __doctest_skip__ = ["clip_score"]
+else:
+    __doctest_skip__ = ["clip_score"]
+    _CLIPModel = None
+    _CLIPProcessor = None
+
+
+class JinaProcessorWrapper:
+    """Wrapper class to convert tensors to PIL images if needed for Jina CLIP model."""
+
+    def __init__(self, processor: _CLIPProcessor) -> None:
+        self.processor = processor
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Wrap the processor's __call__ method to convert tensors to PIL images if needed."""
+        # Check if 'images' is in kwargs and convert tensors to PIL images if needed
+        from torchvision.transforms.functional import to_pil_image
+
+        if "images" in kwargs:
+            kwargs["images"] = [
+                to_pil_image(img.float().cpu()) if isinstance(img, Tensor) else img for img in kwargs["images"]
+            ]
+        return self.processor(*args, **kwargs)
+
+
+def _detect_modality(input_data: Union[Tensor, List[Tensor], List[str], str]) -> Literal["image", "text"]:
+    """Automatically detect the modality of the input data.
+
+    Args:
+        input_data: Input data that can be either image tensors or text strings
+
+    Returns:
+        str: Either "image" or "text"
+
+    Raises:
+        ValueError: If the input_data is an empty list or modality cannot be determined
+
+    """
+    if isinstance(input_data, Tensor):
+        return "image"
+
+    if isinstance(input_data, list):
+        if len(input_data) == 0:
+            raise ValueError("Empty input list")
+        if isinstance(input_data[0], Tensor):
+            return "image"
+        if isinstance(input_data[0], str):
+            return "text"
+
+    if isinstance(input_data, str):
+        return "text"
+
+    raise ValueError("Could not automatically determine modality for input_data")
+
+
+def _process_image_data(images: Union[Tensor, List[Tensor]]) -> List[Tensor]:
+    """Helper function to process image data."""
+    images = [images] if not isinstance(images, list) and images.ndim == 3 else list(images)
+    if not all(i.ndim == 3 for i in images):
+        raise ValueError("Expected all images to be 3d but found image that has either more or less")
+    return images
+
+
+def _process_text_data(texts: Union[str, List[str]]) -> List[str]:
+    """Helper function to process text data."""
+    if not isinstance(texts, list):
+        texts = [texts]
+    return texts
+
+
+def _get_features(
+    data: List[Union[Tensor, str]],
+    modality: str,
+    device: torch.device,
+    model: "_CLIPModel",
+    processor: "_CLIPProcessor",
+) -> Tensor:
+    """Get features from the CLIP model for either images or text.
+
+    Args:
+       data: List of input data (images or text)
+       modality: String indicating the type of input data (must be either "image" or "text")
+       device: Device to run the model on
+       model: CLIP model instance
+       processor: CLIP processor instance
+
+    Returns:
+       Tensor of features from the CLIP model
+
+    Raises:
+        ValueError: If modality is not "image" or "text"
+
+    """
+    if modality == "image":
+        image_data = [i for i in data if isinstance(i, Tensor)]  # Add type checking for images
+        processed = processor(images=[i.cpu() for i in image_data], return_tensors="pt", padding=True)
+        return model.get_image_features(processed["pixel_values"].to(device))
+    if modality == "text":
+        processed = processor(text=data, return_tensors="pt", padding=True)
+        if hasattr(model.config, "text_config") and hasattr(model.config.text_config, "max_position_embeddings"):
+            max_position_embeddings = model.config.text_config.max_position_embeddings
+            if processed["attention_mask"].shape[-1] > max_position_embeddings:
+                rank_zero_warn(
+                    f"Encountered caption longer than {max_position_embeddings=}. Will truncate captions to this"
+                    "length. If longer captions are needed, initialize argument `model_name_or_path` with a model that"
+                    "supports longer sequences.",
+                    UserWarning,
+                )
+                processed["attention_mask"] = processed["attention_mask"][..., :max_position_embeddings]
+                processed["input_ids"] = processed["input_ids"][..., :max_position_embeddings]
+        return model.get_text_features(processed["input_ids"].to(device), processed["attention_mask"].to(device))
+    raise ValueError(f"invalid modality {modality}")
+
+
+def _clip_score_update(
+    source: Union[Tensor, List[Tensor], List[str], str],
+    target: Union[Tensor, List[Tensor], List[str], str],
+    model: _CLIPModel,
+    processor: _CLIPProcessor,
+) -> tuple[Tensor, int]:
+    """Update function for CLIP Score."""
+    source_modality = _detect_modality(source)
+    target_modality = _detect_modality(target)
+
+    source_data = (
+        _process_image_data(cast(Union[Tensor, List[Tensor]], source))
+        if source_modality == "image"
+        else _process_text_data(cast(Union[str, List[str]], source))
+    )
+    target_data = (
+        _process_image_data(cast(Union[Tensor, List[Tensor]], target))
+        if target_modality == "image"
+        else _process_text_data(cast(Union[str, List[str]], target))
+    )
+
+    if len(source_data) != len(target_data):
+        raise ValueError(
+            "Expected the number of source and target examples to be the same but got "
+            f"{len(source_data)} and {len(target_data)}"
+        )
+
+    device = (
+        source_data[0].device
+        if source_modality == "image" and isinstance(source_data[0], Tensor)
+        else target_data[0].device
+        if target_modality == "image" and isinstance(target_data[0], Tensor)
+        else torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    )
+    model = model.to(device)
+
+    source_features = _get_features(
+        cast(List[Union[Tensor, str]], source_data), source_modality, device, model, processor
+    )
+    target_features = _get_features(
+        cast(List[Union[Tensor, str]], target_data), target_modality, device, model, processor
+    )
+    source_features = source_features / source_features.norm(p=2, dim=-1, keepdim=True)
+    target_features = target_features / target_features.norm(p=2, dim=-1, keepdim=True)
+
+    # Calculate cosine similarity
+    score = 100 * (source_features * target_features).sum(axis=-1)
+    score = score.cpu() if source_modality == "text" and target_modality == "text" else score
+    return score, len(source_data)
+
+
+def _get_clip_model_and_processor(
+    model_name_or_path: Union[
+        Literal[
+            "openai/clip-vit-base-patch16",
+            "openai/clip-vit-base-patch32",
+            "openai/clip-vit-large-patch14-336",
+            "openai/clip-vit-large-patch14",
+            "jinaai/jina-clip-v2",
+            "zer0int/LongCLIP-L-Diffusers",
+            "zer0int/LongCLIP-GmP-ViT-L-14",
+        ],
+        Callable[[], tuple[_CLIPModel, _CLIPProcessor]],
+    ],
+) -> tuple[_CLIPModel, _CLIPProcessor]:
+    if callable(model_name_or_path):
+        return model_name_or_path()
+
+    if _TRANSFORMERS_GREATER_EQUAL_4_10:
+        from transformers import AutoModel, AutoProcessor
+        from transformers import CLIPConfig as _CLIPConfig
+        from transformers import CLIPModel as _CLIPModel
+        from transformers import CLIPProcessor as _CLIPProcessor
+
+        if "openai" in model_name_or_path:
+            model = _CLIPModel.from_pretrained(model_name_or_path)
+            processor = _CLIPProcessor.from_pretrained(model_name_or_path)
+        elif "jinaai" in model_name_or_path:
+            model = AutoModel.from_pretrained(model_name_or_path, trust_remote_code=True)
+            processor = JinaProcessorWrapper(
+                processor=AutoProcessor.from_pretrained(model_name_or_path, trust_remote_code=True)
+            )
+        elif "zer0int" in model_name_or_path:
+            config = _CLIPConfig.from_pretrained(model_name_or_path)
+            config.text_config.max_position_embeddings = 248
+            model = _CLIPModel.from_pretrained(model_name_or_path, config=config)
+            processor = _CLIPProcessor.from_pretrained(model_name_or_path, padding="max_length", max_length=248)
+        else:
+            raise ValueError(f"Invalid model_name_or_path {model_name_or_path}. Not supported by `clip_score` metric.")
+        return model, processor
+
+    raise ModuleNotFoundError(
+        "`clip_score` metric requires `transformers` package be installed."
+        " Either install with `pip install transformers>=4.10.0` or `pip install torchmetrics[multimodal]`."
+    )
+
+
+def clip_score(
+    source: Union[Tensor, List[Tensor], List[str], str],
+    target: Union[Tensor, List[Tensor], List[str], str],
+    model_name_or_path: Union[
+        Literal[
+            "openai/clip-vit-base-patch16",
+            "openai/clip-vit-base-patch32",
+            "openai/clip-vit-large-patch14-336",
+            "openai/clip-vit-large-patch14",
+            "jinaai/jina-clip-v2",
+            "zer0int/LongCLIP-L-Diffusers",
+            "zer0int/LongCLIP-GmP-ViT-L-14",
+        ],
+        Callable[[], tuple[_CLIPModel, _CLIPProcessor]],
+    ] = "openai/clip-vit-large-patch14",
+) -> Tensor:
+    r"""Calculates `CLIP Score`_ which is a text-to-image similarity metric.
+
+    CLIP Score is a reference free metric that can be used to evaluate the correlation between a generated caption for
+    an image and the actual content of the image, as well as the similarity between texts or images. It has been found
+    to be highly correlated with human judgement. The metric is defined as:
+
+    .. math::
+        \text{CLIPScore(I, C)} = max(100 * cos(E_I, E_C), 0)
+
+    which corresponds to the cosine similarity between visual `CLIP`_ embedding :math:`E_i` for an image :math:`i` and
+    textual CLIP embedding :math:`E_C` for an caption :math:`C`. The score is bound between 0 and 100 and the closer
+    to 100 the better.
+
+    Additionally, the CLIP Score can be calculated for the same modalities:
+
+    .. math::
+        \text{CLIPScore(I_1, I_2)} = max(100 * cos(E_{I_1}, E_{I_2}), 0)
+
+    where :math:`E_{I_1}` and :math:`E_{I_2}` are the visual embeddings for images :math:`I_1` and :math:`I_2`.
+
+    .. math::
+        \text{CLIPScore(T_1, T_2)} = max(100 * cos(E_{T_1}, E_{T_2}), 0)
+
+    where :math:`E_{T_1}` and :math:`E_{T_2}` are the textual embeddings for texts :math:`T_1` and :math:`T_2`.
+
+    .. note:: Metric is not scriptable
+
+    .. note::
+        The default CLIP and processor used in this implementation has a maximum sequence length of 77 for text
+        inputs. If you need to process longer captions, you can use the `zer0int/LongCLIP-L-Diffusers` model which
+        has a maximum sequence length of 248.
+
+    Args:
+        source: Source input. This can be:
+            - Images: Either a single [N, C, H, W] tensor or a list of [C, H, W] tensors.
+            - Text: Either a single caption or a list of captions.
+        target: Target input. This can be:
+            - Images: Either a single [N, C, H, W] tensor or a list of [C, H, W] tensors.
+            - Text: Either a single caption or a list of captions.
+        model_name_or_path: String indicating the version of the CLIP model to use. Available models are:
+            - `"openai/clip-vit-base-patch16"`
+            - `"openai/clip-vit-base-patch32"`
+            - `"openai/clip-vit-large-patch14-336"`
+            - `"openai/clip-vit-large-patch14"`
+            - `"jinaai/jina-clip-v2"`
+            - `"zer0int/LongCLIP-L-Diffusers"`
+            - `"zer0int/LongCLIP-GmP-ViT-L-14"`
+
+            Alternatively, a callable function that returns a tuple of CLIP compatible model and processor instances
+            can be passed in. By compatible, we mean that the processors `__call__` method should accept a list of
+            strings and list of images and that the model should have a `get_image_features` and `get_text_features`
+            methods.
+
+    Raises:
+        ModuleNotFoundError:
+            If transformers package is not installed or version is lower than 4.10.0
+        ValueError:
+            If not all images have format [C, H, W]
+        ValueError:
+            If the number of images and captions do not match
+
+    Example:
+        >>> from torchmetrics.functional.multimodal import clip_score
+        >>> image = torch.randint(255, (3, 224, 224), generator=torch.Generator().manual_seed(42))
+        >>> score = clip_score(image, "a photo of a cat", "openai/clip-vit-base-patch16")
+        >>> score.detach().round(decimals=3)
+        tensor(24.4260)
+
+    Example:
+        >>> from torchmetrics.functional.multimodal import clip_score
+        >>> image1 = torch.randint(255, (3, 224, 224), generator=torch.Generator().manual_seed(42))
+        >>> image2 = torch.randint(255, (3, 224, 224), generator=torch.Generator().manual_seed(43))
+        >>> score = clip_score(image1, image2, "openai/clip-vit-base-patch16")
+        >>> score.detach().round(decimals=3)
+        tensor(99.4860)
+
+    Example:
+        >>> from torchmetrics.functional.multimodal import clip_score
+        >>> score = clip_score(
+        ...     "28-year-old chef found dead in San Francisco mall",
+        ...     "A 28-year-old chef who recently moved to San Francisco was found dead.",
+        ...     "openai/clip-vit-base-patch16"
+        ... )
+        >>> score.detach().round(decimals=3)
+        tensor(91.3950)
+
+    """
+    model, processor = _get_clip_model_and_processor(model_name_or_path)
+    score, _ = _clip_score_update(source, target, model, processor)
+    score = score.mean(0)
+    return torch.max(score, torch.zeros_like(score))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/multimodal/lve.py

@@ -0,0 +1,93 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import List
+
+import torch
+from torch import Tensor
+
+
+def lip_vertex_error(
+    vertices_pred: Tensor,
+    vertices_gt: Tensor,
+    mouth_map: List[int],
+    validate_args: bool = True,
+) -> Tensor:
+    r"""Compute Lip Vertex Error (LVE) for 3D talking head evaluation.
+
+    The Lip Vertex Error (LVE) metric evaluates the quality of lip synchronization in 3D facial animations by measuring
+    the maximum Euclidean distance (L2 error) between corresponding lip vertices of the generated and ground truth
+    meshes for each frame. The metric is defined as:
+
+    .. math::
+        \text{LVE} = \frac{1}{N} \sum_{i=1}^{N} \max_{v \in \text{lip}} \|x_{i,v} - \hat{x}_{i,v}\|_2^2
+
+    where :math:`N` is the number of frames, :math:`x_{i,v}` represents the 3D coordinates of vertex :math:`v` in the
+    lip region of the ground truth frame :math:`i`, and :math:`\hat{x}_{i,v}` represents the corresponding vertex in
+    the predicted frame. The metric computes the maximum squared L2 distance between corresponding lip vertices for each
+    frame and averages across all frames. A lower LVE value indicates better lip synchronization quality.
+
+    Args:
+        vertices_pred: Predicted vertices tensor of shape (T, V, 3) where T is number of frames,
+            V is number of vertices, and 3 represents XYZ coordinates
+        vertices_gt: Ground truth vertices tensor of shape (T', V, 3) where T' can be different from T
+        mouth_map: List of vertex indices corresponding to the mouth region
+        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
+            Set to ``False`` for faster computations.
+
+    Returns:
+        torch.Tensor: Scalar tensor containing the mean LVE value across all frames
+
+    Raises:
+        ValueError:
+            If the number of dimensions of `vertices_pred` or `vertices_gt` is not 3.
+            If vertex dimensions (V) or coordinate dimensions (3) don't match
+            If ``mouth_map`` is empty or contains invalid indices
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.multimodal import lip_vertex_error
+        >>> vertices_pred = torch.randn(10, 100, 3, generator=torch.manual_seed(42))
+        >>> vertices_gt = torch.randn(10, 100, 3, generator=torch.manual_seed(43))
+        >>> mouth_map = [0, 1, 2, 3, 4]
+        >>> lip_vertex_error(vertices_pred, vertices_gt, mouth_map)
+        tensor(12.7688)
+
+    """
+    if validate_args:
+        if vertices_pred.ndim != 3 or vertices_gt.ndim != 3:
+            raise ValueError(
+                f"Expected both vertices_pred and vertices_gt to have 3 dimensions but got "
+                f"{vertices_pred.ndim} and {vertices_gt.ndim} dimensions respectively."
+            )
+        if vertices_pred.shape[1:] != vertices_gt.shape[1:]:
+            raise ValueError(
+                f"Expected vertices_pred and vertices_gt to have same vertex and coordinate dimensions but got "
+                f"shapes {vertices_pred.shape} and {vertices_gt.shape}."
+            )
+        if not mouth_map:
+            raise ValueError("mouth_map cannot be empty.")
+        if max(mouth_map) >= vertices_pred.shape[1]:
+            raise ValueError(
+                f"mouth_map contains invalid vertex indices. Max index {max(mouth_map)} is larger than "
+                f"number of vertices {vertices_pred.shape[1]}."
+            )
+
+    min_frames = min(vertices_pred.shape[0], vertices_gt.shape[0])
+    vertices_pred = vertices_pred[:min_frames]
+    vertices_gt = vertices_gt[:min_frames]
+
+    diff = vertices_gt[:, mouth_map, :] - vertices_pred[:, mouth_map, :]  # Shape: (T, M, 3)
+    sq_dist = torch.sum(diff**2, dim=-1)  # Shape: (T, M)
+    max_per_frame = torch.max(sq_dist, dim=1).values  # Shape: (T,)
+    return torch.mean(max_per_frame)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/nominal/__init__.py

@@ -0,0 +1,34 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from torchmetrics.functional.nominal.cramers import cramers_v, cramers_v_matrix
+from torchmetrics.functional.nominal.fleiss_kappa import fleiss_kappa
+from torchmetrics.functional.nominal.pearson import (
+    pearsons_contingency_coefficient,
+    pearsons_contingency_coefficient_matrix,
+)
+from torchmetrics.functional.nominal.theils_u import theils_u, theils_u_matrix
+from torchmetrics.functional.nominal.tschuprows import tschuprows_t, tschuprows_t_matrix
+
+__all__ = [
+    "cramers_v",
+    "cramers_v_matrix",
+    "fleiss_kappa",
+    "pearsons_contingency_coefficient",
+    "pearsons_contingency_coefficient_matrix",
+    "theils_u",
+    "theils_u_matrix",
+    "tschuprows_t",
+    "tschuprows_t_matrix",
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/nominal/cramers.py

@@ -0,0 +1,183 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.classification.confusion_matrix import _multiclass_confusion_matrix_update
+from torchmetrics.functional.nominal.utils import (
+    _compute_bias_corrected_values,
+    _compute_chi_squared,
+    _drop_empty_rows_and_cols,
+    _handle_nan_in_data,
+    _nominal_input_validation,
+    _unable_to_use_bias_correction_warning,
+)
+
+
+def _cramers_v_update(
+    preds: Tensor,
+    target: Tensor,
+    num_classes: int,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    """Compute the bins to update the confusion matrix with for Cramer's V calculation.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data
+        target: 1D or 2D tensor of categorical (nominal) data
+        num_classes: Integer specifying the number of classes
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN`s when ``nan_strategy = 'replace```
+
+    Returns:
+        Non-reduced confusion matrix
+
+    """
+    preds = preds.argmax(1) if preds.ndim == 2 else preds
+    target = target.argmax(1) if target.ndim == 2 else target
+    preds, target = _handle_nan_in_data(preds, target, nan_strategy, nan_replace_value)
+    return _multiclass_confusion_matrix_update(preds, target, num_classes)
+
+
+def _cramers_v_compute(confmat: Tensor, bias_correction: bool) -> Tensor:
+    """Compute Cramers' V statistic based on a pre-computed confusion matrix.
+
+    Args:
+        confmat: Confusion matrix for observed data
+        bias_correction: Indication of whether to use bias correction.
+
+    Returns:
+        Cramer's V statistic
+
+    """
+    confmat = _drop_empty_rows_and_cols(confmat)
+    cm_sum = confmat.sum()
+    chi_squared = _compute_chi_squared(confmat, bias_correction)
+    phi_squared = chi_squared / cm_sum
+    num_rows, num_cols = confmat.shape
+
+    if bias_correction:
+        phi_squared_corrected, rows_corrected, cols_corrected = _compute_bias_corrected_values(
+            phi_squared, num_rows, num_cols, cm_sum
+        )
+        if torch.min(rows_corrected, cols_corrected) == 1:
+            _unable_to_use_bias_correction_warning(metric_name="Cramer's V")
+            return torch.tensor(float("nan"), device=confmat.device)
+        cramers_v_value = torch.sqrt(phi_squared_corrected / torch.min(rows_corrected - 1, cols_corrected - 1))
+    else:
+        cramers_v_value = torch.sqrt(phi_squared / min(num_rows - 1, num_cols - 1))
+    return cramers_v_value.clamp(0.0, 1.0)
+
+
+def cramers_v(
+    preds: Tensor,
+    target: Tensor,
+    bias_correction: bool = True,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Cramer's V`_ statistic measuring the association between two categorical (nominal) data series.
+
+    .. math::
+        V = \sqrt{\frac{\chi^2 / n}{\min(r - 1, k - 1)}}
+
+    where
+
+    .. math::
+        \chi^2 = \sum_{i,j} \ frac{\left(n_{ij} - \frac{n_{i.} n_{.j}}{n}\right)^2}{\frac{n_{i.} n_{.j}}{n}}
+
+    where :math:`n_{ij}` denotes the number of times the values :math:`(A_i, B_j)` are observed with :math:`A_i, B_j`
+    represent frequencies of values in ``preds`` and ``target``, respectively.
+
+    Cramer's V is a symmetric coefficient, i.e. :math:`V(preds, target) = V(target, preds)`.
+
+    The output values lies in [0, 1] with 1 meaning the perfect association.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+        target: 1D or 2D tensor of categorical (nominal) data
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+        bias_correction: Indication of whether to use bias correction.
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Cramer's V statistic
+
+    Example:
+        >>> from torch import randint, round
+        >>> from torchmetrics.functional.nominal import cramers_v
+        >>> preds = randint(0, 4, (100,))
+        >>> target = round(preds + torch.randn(100)).clamp(0, 4)
+        >>> cramers_v(preds, target)
+        tensor(0.5284)
+
+    """
+    _nominal_input_validation(nan_strategy, nan_replace_value)
+    num_classes = len(torch.cat([preds, target]).unique())
+    confmat = _cramers_v_update(preds, target, num_classes, nan_strategy, nan_replace_value)
+    return _cramers_v_compute(confmat, bias_correction)
+
+
+def cramers_v_matrix(
+    matrix: Tensor,
+    bias_correction: bool = True,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Cramer's V`_ statistic between a set of multiple variables.
+
+    This can serve as a convenient tool to compute Cramer's V statistic for analyses of correlation between categorical
+    variables in your dataset.
+
+    Args:
+        matrix: A tensor of categorical (nominal) data, where:
+            - rows represent a number of data points
+            - columns represent a number of categorical (nominal) features
+        bias_correction: Indication of whether to use bias correction.
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Cramer's V statistic for a dataset of categorical variables
+
+    Example:
+        >>> from torch import randint
+        >>> from torchmetrics.functional.nominal import cramers_v_matrix
+        >>> matrix = randint(0, 4, (200, 5))
+        >>> cramers_v_matrix(matrix)
+        tensor([[1.0000, 0.0637, 0.0000, 0.0542, 0.1337],
+                [0.0637, 1.0000, 0.0000, 0.0000, 0.0000],
+                [0.0000, 0.0000, 1.0000, 0.0000, 0.0649],
+                [0.0542, 0.0000, 0.0000, 1.0000, 0.1100],
+                [0.1337, 0.0000, 0.0649, 0.1100, 1.0000]])
+
+    """
+    _nominal_input_validation(nan_strategy, nan_replace_value)
+    num_variables = matrix.shape[1]
+    cramers_v_matrix_value = torch.ones(num_variables, num_variables, device=matrix.device)
+    for i, j in itertools.combinations(range(num_variables), 2):
+        x, y = matrix[:, i], matrix[:, j]
+        num_classes = len(torch.cat([x, y]).unique())
+        confmat = _cramers_v_update(x, y, num_classes, nan_strategy, nan_replace_value)
+        cramers_v_matrix_value[i, j] = cramers_v_matrix_value[j, i] = _cramers_v_compute(confmat, bias_correction)
+    return cramers_v_matrix_value

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/nominal/fleiss_kappa.py

@@ -0,0 +1,99 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+
+def _fleiss_kappa_update(ratings: Tensor, mode: Literal["counts", "probs"] = "counts") -> Tensor:
+    """Updates the counts for fleiss kappa metric.
+
+    Args:
+        ratings: ratings matrix
+        mode: whether ratings are provided as counts or probabilities
+
+    """
+    if mode == "probs":
+        if ratings.ndim != 3 or not ratings.is_floating_point():
+            raise ValueError(
+                "If argument ``mode`` is 'probs', ratings must have 3 dimensions with the format"
+                " [n_samples, n_categories, n_raters] and be floating point."
+            )
+        ratings = ratings.argmax(dim=1)
+        one_hot = torch.nn.functional.one_hot(ratings, num_classes=ratings.shape[1]).permute(0, 2, 1)
+        ratings = one_hot.sum(dim=-1)
+    elif mode == "counts" and (ratings.ndim != 2 or ratings.is_floating_point()):
+        raise ValueError(
+            "If argument ``mode`` is `counts`, ratings must have 2 dimensions with the format"
+            " [n_samples, n_categories] and be none floating point."
+        )
+    return ratings
+
+
+def _fleiss_kappa_compute(counts: Tensor) -> Tensor:
+    """Computes fleiss kappa from counts matrix.
+
+    Args:
+        counts: counts matrix of shape [n_samples, n_categories]
+
+    """
+    total = counts.shape[0]
+    num_raters = counts.sum(1).max()
+
+    p_i = counts.sum(dim=0) / (total * num_raters)
+    p_j = ((counts**2).sum(dim=1) - num_raters) / (num_raters * (num_raters - 1))
+    p_bar = p_j.mean()
+    pe_bar = (p_i**2).sum()
+    return (p_bar - pe_bar) / (1 - pe_bar + 1e-5)
+
+
+def fleiss_kappa(ratings: Tensor, mode: Literal["counts", "probs"] = "counts") -> Tensor:
+    r"""Calculatees `Fleiss kappa`_ a statistical measure for inter agreement between raters.
+
+    .. math::
+        \kappa = \frac{\bar{p} - \bar{p_e}}{1 - \bar{p_e}}
+
+    where :math:`\bar{p}` is the mean of the agreement probability over all raters and :math:`\bar{p_e}` is the mean
+    agreement probability over all raters if they were randomly assigned. If the raters are in complete agreement then
+    the score 1 is returned, if there is no agreement among the raters (other than what would be expected by chance)
+    then a score smaller than 0 is returned.
+
+    Args:
+        ratings: Ratings of shape [n_samples, n_categories] or [n_samples, n_categories, n_raters] depedenent on `mode`.
+            If `mode` is `counts`, `ratings` must be integer and contain the number of raters that chose each category.
+            If `mode` is `probs`, `ratings` must be floating point and contain the probability/logits that each rater
+            chose each category.
+        mode: Whether `ratings` will be provided as counts or probabilities.
+
+    Example:
+        >>> # Ratings are provided as counts
+        >>> from torch import randint
+        >>> from torchmetrics.functional.nominal import fleiss_kappa
+        >>> ratings = randint(0, 10, size=(100, 5)).long()  # 100 samples, 5 categories, 10 raters
+        >>> fleiss_kappa(ratings)
+        tensor(0.0089)
+
+    Example:
+        >>> # Ratings are provided as probabilities
+        >>> from torch import randn
+        >>> from torchmetrics.functional.nominal import fleiss_kappa
+        >>> ratings = randn(100, 5, 10).softmax(dim=1)  # 100 samples, 5 categories, 10 raters
+        >>> fleiss_kappa(ratings, mode='probs')
+        tensor(-0.0075)
+
+    """
+    if mode not in ["counts", "probs"]:
+        raise ValueError("Argument ``mode`` must be one of ['counts', 'probs'].")
+    counts = _fleiss_kappa_update(ratings, mode)
+    return _fleiss_kappa_compute(counts)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/nominal/pearson.py

@@ -0,0 +1,174 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.classification.confusion_matrix import _multiclass_confusion_matrix_update
+from torchmetrics.functional.nominal.utils import (
+    _compute_chi_squared,
+    _drop_empty_rows_and_cols,
+    _handle_nan_in_data,
+    _nominal_input_validation,
+)
+
+
+def _pearsons_contingency_coefficient_update(
+    preds: Tensor,
+    target: Tensor,
+    num_classes: int,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    """Compute the bins to update the confusion matrix with for Pearson's Contingency Coefficient calculation.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data
+        target: 1D or 2D tensor of categorical (nominal) data
+        num_classes: Integer specifying the number of classes
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN`s when ``nan_strategy = 'replace```
+
+    Returns:
+        Non-reduced confusion matrix
+
+    """
+    preds = preds.argmax(1) if preds.ndim == 2 else preds
+    target = target.argmax(1) if target.ndim == 2 else target
+    preds, target = _handle_nan_in_data(preds, target, nan_strategy, nan_replace_value)
+    return _multiclass_confusion_matrix_update(preds, target, num_classes)
+
+
+def _pearsons_contingency_coefficient_compute(confmat: Tensor) -> Tensor:
+    """Compute Pearson's Contingency Coefficient based on a pre-computed confusion matrix.
+
+    Args:
+        confmat: Confusion matrix for observed data
+
+    Returns:
+        Pearson's Contingency Coefficient
+
+    """
+    confmat = _drop_empty_rows_and_cols(confmat)
+    cm_sum = confmat.sum()
+    chi_squared = _compute_chi_squared(confmat, bias_correction=False)
+    phi_squared = chi_squared / cm_sum
+
+    tschuprows_t_value = torch.sqrt(phi_squared / (1 + phi_squared))
+    return tschuprows_t_value.clamp(0.0, 1.0)
+
+
+def pearsons_contingency_coefficient(
+    preds: Tensor,
+    target: Tensor,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Pearson's Contingency Coefficient`_ for measuring the association between two categorical data series.
+
+    .. math::
+        Pearson = \sqrt{\frac{\chi^2 / n}{1 + \chi^2 / n}}
+
+    where
+
+    .. math::
+        \chi^2 = \sum_{i,j} \ frac{\left(n_{ij} - \frac{n_{i.} n_{.j}}{n}\right)^2}{\frac{n_{i.} n_{.j}}{n}}
+
+    where :math:`n_{ij}` denotes the number of times the values :math:`(A_i, B_j)` are observed with :math:`A_i, B_j`
+    represent frequencies of values in ``preds`` and ``target``, respectively.
+
+    Pearson's Contingency Coefficient is a symmetric coefficient, i.e.
+    :math:`Pearson(preds, target) = Pearson(target, preds)`.
+
+    The output values lies in [0, 1] with 1 meaning the perfect association.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data:
+
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+
+        target: 1D or 2D tensor of categorical (nominal) data:
+
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Pearson's Contingency Coefficient
+
+    Example:
+        >>> from torch import randint, round
+        >>> from torchmetrics.functional.nominal import pearsons_contingency_coefficient
+        >>> preds = randint(0, 4, (100,))
+        >>> target = round(preds + torch.randn(100)).clamp(0, 4)
+        >>> pearsons_contingency_coefficient(preds, target)
+        tensor(0.6948)
+
+    """
+    _nominal_input_validation(nan_strategy, nan_replace_value)
+    num_classes = len(torch.cat([preds, target]).unique())
+    confmat = _pearsons_contingency_coefficient_update(preds, target, num_classes, nan_strategy, nan_replace_value)
+    return _pearsons_contingency_coefficient_compute(confmat)
+
+
+def pearsons_contingency_coefficient_matrix(
+    matrix: Tensor,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Pearson's Contingency Coefficient`_ statistic between a set of multiple variables.
+
+    This can serve as a convenient tool to compute Pearson's Contingency Coefficient for analyses
+    of correlation between categorical variables in your dataset.
+
+    Args:
+        matrix: A tensor of categorical (nominal) data, where:
+
+            - rows represent a number of data points
+            - columns represent a number of categorical (nominal) features
+
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Pearson's Contingency Coefficient statistic for a dataset of categorical variables
+
+    Example:
+        >>> from torch import randint
+        >>> from torchmetrics.functional.nominal import pearsons_contingency_coefficient_matrix
+        >>> matrix = randint(0, 4, (200, 5))
+        >>> pearsons_contingency_coefficient_matrix(matrix)
+        tensor([[1.0000, 0.2326, 0.1959, 0.2262, 0.2989],
+                [0.2326, 1.0000, 0.1386, 0.1895, 0.1329],
+                [0.1959, 0.1386, 1.0000, 0.1840, 0.2335],
+                [0.2262, 0.1895, 0.1840, 1.0000, 0.2737],
+                [0.2989, 0.1329, 0.2335, 0.2737, 1.0000]])
+
+    """
+    _nominal_input_validation(nan_strategy, nan_replace_value)
+    num_variables = matrix.shape[1]
+    pearsons_cont_coef_matrix_value = torch.ones(num_variables, num_variables, device=matrix.device)
+    for i, j in itertools.combinations(range(num_variables), 2):
+        x, y = matrix[:, i], matrix[:, j]
+        num_classes = len(torch.cat([x, y]).unique())
+        confmat = _pearsons_contingency_coefficient_update(x, y, num_classes, nan_strategy, nan_replace_value)
+        val = _pearsons_contingency_coefficient_compute(confmat)
+        pearsons_cont_coef_matrix_value[i, j] = pearsons_cont_coef_matrix_value[j, i] = val
+    return pearsons_cont_coef_matrix_value

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/nominal/theils_u.py

@@ -0,0 +1,195 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.classification.confusion_matrix import _multiclass_confusion_matrix_update
+from torchmetrics.functional.nominal.utils import (
+    _drop_empty_rows_and_cols,
+    _handle_nan_in_data,
+    _nominal_input_validation,
+)
+
+
+def _conditional_entropy_compute(confmat: Tensor) -> Tensor:
+    r"""Compute Conditional Entropy Statistic based on a pre-computed confusion matrix.
+
+    .. math::
+        H(X|Y) = \sum_{x, y ~ (X, Y)} p(x, y)\frac{p(y)}{p(x, y)}
+
+    Args:
+        confmat: Confusion matrix for observed data
+
+    Returns:
+        Conditional Entropy Value
+
+    """
+    confmat = _drop_empty_rows_and_cols(confmat)
+    total_occurrences = confmat.sum()
+    # iterate over all i, j combinations
+    p_xy_m = confmat / total_occurrences
+    # get p_y by summing over x dim (=1)
+    p_y = confmat.sum(1) / total_occurrences
+    # repeat over rows (shape = p_xy_m.shape[1]) for tensor multiplication
+    p_y_m = p_y.unsqueeze(1).repeat(1, p_xy_m.shape[1])
+
+    # entropy calculated as p_xy * log (p_xy / p_y)
+    return torch.nansum(p_xy_m * torch.log(p_y_m / p_xy_m))
+
+
+def _theils_u_update(
+    preds: Tensor,
+    target: Tensor,
+    num_classes: int,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    """Compute the bins to update the confusion matrix with for Theil's U calculation.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data
+        target: 1D or 2D tensor of categorical (nominal) data
+        num_classes: Integer specifying the number of classes
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN`s when ``nan_strategy = 'replace```
+
+    Returns:
+        Non-reduced confusion matrix
+
+    """
+    preds = preds.argmax(1) if preds.ndim == 2 else preds
+    target = target.argmax(1) if target.ndim == 2 else target
+    preds, target = _handle_nan_in_data(preds, target, nan_strategy, nan_replace_value)
+    return _multiclass_confusion_matrix_update(preds, target, num_classes)
+
+
+def _theils_u_compute(confmat: Tensor) -> Tensor:
+    """Compute Theil's U statistic based on a pre-computed confusion matrix.
+
+    Args:
+        confmat: Confusion matrix for observed data
+
+    Returns:
+        Theil's U statistic
+
+    """
+    confmat = _drop_empty_rows_and_cols(confmat)
+
+    # compute conditional entropy
+    s_xy = _conditional_entropy_compute(confmat)
+
+    # compute H(x)
+    total_occurrences = confmat.sum()
+    p_x = confmat.sum(0) / total_occurrences
+    s_x = -torch.sum(p_x * torch.log(p_x))
+
+    # compute u statistic
+    if s_x == 0:
+        return torch.tensor(0, device=confmat.device)
+
+    return (s_x - s_xy) / s_x
+
+
+def theils_u(
+    preds: Tensor,
+    target: Tensor,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Theils Uncertainty coefficient`_ statistic measuring the association between two nominal data series.
+
+    .. math::
+        U(X|Y) = \frac{H(X) - H(X|Y)}{H(X)}
+
+    where :math:`H(X)` is entropy of variable :math:`X` while :math:`H(X|Y)` is the conditional entropy of :math:`X`
+    given :math:`Y`.
+
+    Theils's U is an asymmetric coefficient, i.e. :math:`TheilsU(preds, target) \neq TheilsU(target, preds)`.
+
+    The output values lies in [0, 1]. 0 means y has no information about x while value 1 means y has complete
+    information about x.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+        target: 1D or 2D tensor of categorical (nominal) data
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Tensor containing Theil's U statistic
+
+    Example:
+        >>> from torch import randint
+        >>> from torchmetrics.functional.nominal import theils_u
+        >>> preds = randint(10, (10,))
+        >>> target = randint(10, (10,))
+        >>> theils_u(preds, target)
+        tensor(0.8530)
+
+    """
+    num_classes = len(torch.cat([preds, target]).unique())
+    confmat = _theils_u_update(preds, target, num_classes, nan_strategy, nan_replace_value)
+    return _theils_u_compute(confmat)
+
+
+def theils_u_matrix(
+    matrix: Tensor,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Theil's U`_ statistic between a set of multiple variables.
+
+    This can serve as a convenient tool to compute Theil's U statistic for analyses of correlation between categorical
+    variables in your dataset.
+
+    Args:
+        matrix: A tensor of categorical (nominal) data, where:
+            - rows represent a number of data points
+            - columns represent a number of categorical (nominal) features
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Theil's U statistic for a dataset of categorical variables
+
+    Example:
+        >>> from torch import randint
+        >>> from torchmetrics.functional.nominal import theils_u_matrix
+        >>> matrix = randint(0, 4, (200, 5))
+        >>> theils_u_matrix(matrix)
+        tensor([[1.0000, 0.0202, 0.0142, 0.0196, 0.0353],
+                [0.0202, 1.0000, 0.0070, 0.0136, 0.0065],
+                [0.0143, 0.0070, 1.0000, 0.0125, 0.0206],
+                [0.0198, 0.0137, 0.0125, 1.0000, 0.0312],
+                [0.0352, 0.0065, 0.0204, 0.0308, 1.0000]])
+
+    """
+    _nominal_input_validation(nan_strategy, nan_replace_value)
+    num_variables = matrix.shape[1]
+    theils_u_matrix_value = torch.ones(num_variables, num_variables, device=matrix.device)
+    for i, j in itertools.combinations(range(num_variables), 2):
+        x, y = matrix[:, i], matrix[:, j]
+        num_classes = len(torch.cat([x, y]).unique())
+        confmat = _theils_u_update(x, y, num_classes, nan_strategy, nan_replace_value)
+        theils_u_matrix_value[i, j] = _theils_u_compute(confmat)
+        theils_u_matrix_value[j, i] = _theils_u_compute(confmat.T)
+    return theils_u_matrix_value

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/nominal/tschuprows.py

@@ -0,0 +1,193 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.classification.confusion_matrix import _multiclass_confusion_matrix_update
+from torchmetrics.functional.nominal.utils import (
+    _compute_bias_corrected_values,
+    _compute_chi_squared,
+    _drop_empty_rows_and_cols,
+    _handle_nan_in_data,
+    _nominal_input_validation,
+    _unable_to_use_bias_correction_warning,
+)
+
+
+def _tschuprows_t_update(
+    preds: Tensor,
+    target: Tensor,
+    num_classes: int,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    """Compute the bins to update the confusion matrix with for Tschuprow's T calculation.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data
+        target: 1D or 2D tensor of categorical (nominal) data
+        num_classes: Integer specifying the number of classes
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN`s when ``nan_strategy = 'replace```
+
+    Returns:
+        Non-reduced confusion matrix
+
+    """
+    preds = preds.argmax(1) if preds.ndim == 2 else preds
+    target = target.argmax(1) if target.ndim == 2 else target
+    preds, target = _handle_nan_in_data(preds, target, nan_strategy, nan_replace_value)
+    return _multiclass_confusion_matrix_update(preds, target, num_classes)
+
+
+def _tschuprows_t_compute(confmat: Tensor, bias_correction: bool) -> Tensor:
+    """Compute Tschuprow's T statistic based on a pre-computed confusion matrix.
+
+    Args:
+        confmat: Confusion matrix for observed data
+        bias_correction: Indication of whether to use bias correction.
+
+    Returns:
+        Tschuprow's T statistic
+
+    """
+    confmat = _drop_empty_rows_and_cols(confmat)
+    cm_sum = confmat.sum()
+    chi_squared = _compute_chi_squared(confmat, bias_correction)
+    phi_squared = chi_squared / cm_sum
+    num_rows, num_cols = confmat.shape
+
+    if bias_correction:
+        phi_squared_corrected, rows_corrected, cols_corrected = _compute_bias_corrected_values(
+            phi_squared, num_rows, num_cols, cm_sum
+        )
+        if torch.min(rows_corrected, cols_corrected) == 1:
+            _unable_to_use_bias_correction_warning(metric_name="Tschuprow's T")
+            return torch.tensor(float("nan"), device=confmat.device)
+        tschuprows_t_value = torch.sqrt(phi_squared_corrected / torch.sqrt((rows_corrected - 1) * (cols_corrected - 1)))
+    else:
+        n_rows_tensor = torch.tensor(num_rows, device=phi_squared.device)
+        n_cols_tensor = torch.tensor(num_cols, device=phi_squared.device)
+        tschuprows_t_value = torch.sqrt(phi_squared / torch.sqrt((n_rows_tensor - 1) * (n_cols_tensor - 1)))
+    return tschuprows_t_value.clamp(0.0, 1.0)
+
+
+def tschuprows_t(
+    preds: Tensor,
+    target: Tensor,
+    bias_correction: bool = True,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Tschuprow's T`_ statistic measuring the association between two categorical (nominal) data series.
+
+    .. math::
+        T = \sqrt{\frac{\chi^2 / n}{\sqrt{(r - 1) * (k - 1)}}}
+
+    where
+
+    .. math::
+        \chi^2 = \sum_{i,j} \ frac{\left(n_{ij} - \frac{n_{i.} n_{.j}}{n}\right)^2}{\frac{n_{i.} n_{.j}}{n}}
+
+    where :math:`n_{ij}` denotes the number of times the values :math:`(A_i, B_j)` are observed with :math:`A_i, B_j`
+    represent frequencies of values in ``preds`` and ``target``, respectively.
+
+    Tschuprow's T is a symmetric coefficient, i.e. :math:`T(preds, target) = T(target, preds)`.
+
+    The output values lies in [0, 1] with 1 meaning the perfect association.
+
+    Args:
+        preds: 1D or 2D tensor of categorical (nominal) data:
+
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+
+        target: 1D or 2D tensor of categorical (nominal) data:
+
+            - 1D shape: (batch_size,)
+            - 2D shape: (batch_size, num_classes)
+
+        bias_correction: Indication of whether to use bias correction.
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Tschuprow's T statistic
+
+    Example:
+        >>> from torch import randint, round
+        >>> from torchmetrics.functional.nominal import tschuprows_t
+        >>> preds = randint(0, 4, (100,))
+        >>> target = round(preds + torch.randn(100)).clamp(0, 4)
+        >>> tschuprows_t(preds, target)
+        tensor(0.4930)
+
+    """
+    _nominal_input_validation(nan_strategy, nan_replace_value)
+    num_classes = len(torch.cat([preds, target]).unique())
+    confmat = _tschuprows_t_update(preds, target, num_classes, nan_strategy, nan_replace_value)
+    return _tschuprows_t_compute(confmat, bias_correction)
+
+
+def tschuprows_t_matrix(
+    matrix: Tensor,
+    bias_correction: bool = True,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> Tensor:
+    r"""Compute `Tschuprow's T`_ statistic between a set of multiple variables.
+
+    This can serve as a convenient tool to compute Tschuprow's T statistic for analyses of correlation between
+    categorical variables in your dataset.
+
+    Args:
+        matrix: A tensor of categorical (nominal) data, where:
+
+            - rows represent a number of data points
+            - columns represent a number of categorical (nominal) features
+
+        bias_correction: Indication of whether to use bias correction.
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN``s when ``nan_strategy = 'replace'``
+
+    Returns:
+        Tschuprow's T statistic for a dataset of categorical variables
+
+    Example:
+        >>> from torch import randint
+        >>> from torchmetrics.functional.nominal import tschuprows_t_matrix
+        >>> matrix = randint(0, 4, (200, 5))
+        >>> tschuprows_t_matrix(matrix)
+        tensor([[1.0000, 0.0637, 0.0000, 0.0542, 0.1337],
+                [0.0637, 1.0000, 0.0000, 0.0000, 0.0000],
+                [0.0000, 0.0000, 1.0000, 0.0000, 0.0649],
+                [0.0542, 0.0000, 0.0000, 1.0000, 0.1100],
+                [0.1337, 0.0000, 0.0649, 0.1100, 1.0000]])
+
+    """
+    _nominal_input_validation(nan_strategy, nan_replace_value)
+    num_variables = matrix.shape[1]
+    tschuprows_t_matrix_value = torch.ones(num_variables, num_variables, device=matrix.device)
+    for i, j in itertools.combinations(range(num_variables), 2):
+        x, y = matrix[:, i], matrix[:, j]
+        num_classes = len(torch.cat([x, y]).unique())
+        confmat = _tschuprows_t_update(x, y, num_classes, nan_strategy, nan_replace_value)
+        tschuprows_t_matrix_value[i, j] = tschuprows_t_matrix_value[j, i] = _tschuprows_t_compute(
+            confmat, bias_correction
+        )
+    return tschuprows_t_matrix_value

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/nominal/utils.py

@@ -0,0 +1,146 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.utilities.prints import rank_zero_warn
+
+
+def _nominal_input_validation(nan_strategy: str, nan_replace_value: Optional[float]) -> None:
+    if nan_strategy not in ["replace", "drop"]:
+        raise ValueError(
+            f"Argument `nan_strategy` is expected to be one of `['replace', 'drop']`, but got {nan_strategy}"
+        )
+    if nan_strategy == "replace" and not isinstance(nan_replace_value, (float, int)):
+        raise ValueError(
+            "Argument `nan_replace` is expected to be of a type `int` or `float` when `nan_strategy = 'replace`, "
+            f"but got {nan_replace_value}"
+        )
+
+
+def _compute_expected_freqs(confmat: Tensor) -> Tensor:
+    """Compute the expected frequenceis from the provided confusion matrix."""
+    margin_sum_rows, margin_sum_cols = confmat.sum(1), confmat.sum(0)
+    return torch.einsum("r, c -> rc", margin_sum_rows, margin_sum_cols) / confmat.sum()
+
+
+def _compute_chi_squared(confmat: Tensor, bias_correction: bool) -> Tensor:
+    """Chi-square test of independenc of variables in a confusion matrix table.
+
+    Adapted from: https://github.com/scipy/scipy/blob/v1.9.2/scipy/stats/contingency.py.
+
+    """
+    expected_freqs = _compute_expected_freqs(confmat)
+    # Get degrees of freedom
+    df = expected_freqs.numel() - sum(expected_freqs.shape) + expected_freqs.ndim - 1
+    if df == 0:
+        return torch.tensor(0.0, device=confmat.device)
+
+    if df == 1 and bias_correction:
+        diff = expected_freqs - confmat
+        direction = diff.sign()
+        confmat += direction * torch.minimum(0.5 * torch.ones_like(direction), direction.abs())
+
+    return torch.sum((confmat - expected_freqs) ** 2 / expected_freqs)
+
+
+def _drop_empty_rows_and_cols(confmat: Tensor) -> Tensor:
+    """Drop all rows and columns containing only zeros.
+
+    Example:
+        >>> from torch import randint
+        >>> from torchmetrics.functional.nominal.utils import _drop_empty_rows_and_cols
+        >>> matrix = randint(10, size=(4, 3))
+        >>> matrix[1, :] = matrix[:, 1] = 0
+        >>> matrix
+        tensor([[2, 0, 6],
+                [0, 0, 0],
+                [0, 0, 0],
+                [3, 0, 4]])
+        >>> _drop_empty_rows_and_cols(matrix)
+        tensor([[2, 6],
+                [3, 4]])
+
+    """
+    confmat = confmat[confmat.sum(1) != 0]
+    return confmat[:, confmat.sum(0) != 0]
+
+
+def _compute_phi_squared_corrected(
+    phi_squared: Tensor,
+    num_rows: int,
+    num_cols: int,
+    confmat_sum: Tensor,
+) -> Tensor:
+    """Compute bias-corrected Phi Squared."""
+    return torch.max(
+        torch.tensor(0.0, device=phi_squared.device),
+        phi_squared - ((num_rows - 1) * (num_cols - 1)) / (confmat_sum - 1),
+    )
+
+
+def _compute_rows_and_cols_corrected(num_rows: int, num_cols: int, confmat_sum: Tensor) -> tuple[Tensor, Tensor]:
+    """Compute bias-corrected number of rows and columns."""
+    rows_corrected = num_rows - (num_rows - 1) ** 2 / (confmat_sum - 1)
+    cols_corrected = num_cols - (num_cols - 1) ** 2 / (confmat_sum - 1)
+    return rows_corrected, cols_corrected
+
+
+def _compute_bias_corrected_values(
+    phi_squared: Tensor, num_rows: int, num_cols: int, confmat_sum: Tensor
+) -> tuple[Tensor, Tensor, Tensor]:
+    """Compute bias-corrected Phi Squared and number of rows and columns."""
+    phi_squared_corrected = _compute_phi_squared_corrected(phi_squared, num_rows, num_cols, confmat_sum)
+    rows_corrected, cols_corrected = _compute_rows_and_cols_corrected(num_rows, num_cols, confmat_sum)
+    return phi_squared_corrected, rows_corrected, cols_corrected
+
+
+def _handle_nan_in_data(
+    preds: Tensor,
+    target: Tensor,
+    nan_strategy: Literal["replace", "drop"] = "replace",
+    nan_replace_value: Optional[float] = 0.0,
+) -> tuple[Tensor, Tensor]:
+    """Handle ``NaN`` values in input data.
+
+    If ``nan_strategy = 'replace'``, all ``NaN`` values are replaced with ``nan_replace_value``.
+    If ``nan_strategy = 'drop'``, all rows containing ``NaN`` in any of two vectors are dropped.
+
+    Args:
+        preds: 1D tensor of categorical (nominal) data
+        target: 1D tensor of categorical (nominal) data
+        nan_strategy: Indication of whether to replace or drop ``NaN`` values
+        nan_replace_value: Value to replace ``NaN`s when ``nan_strategy = 'replace```
+
+    Returns:
+        Updated ``preds`` and ``target`` tensors which contain no ``Nan``
+
+    Raises:
+        ValueError: If ``nan_strategy`` is not from ``['replace', 'drop']``.
+        ValueError: If ``nan_strategy = replace`` and ``nan_replace_value`` is not of a type ``int`` or ``float``.
+
+    """
+    if nan_strategy == "replace":
+        return preds.nan_to_num(nan_replace_value), target.nan_to_num(nan_replace_value)
+    rows_contain_nan = torch.logical_or(preds.isnan(), target.isnan())
+    return preds[~rows_contain_nan], target[~rows_contain_nan]
+
+
+def _unable_to_use_bias_correction_warning(metric_name: str) -> None:
+    rank_zero_warn(
+        f"Unable to compute {metric_name} using bias correction. Please consider to set `bias_correction=False`."
+    )

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/pairwise/__init__.py

@@ -0,0 +1,26 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from torchmetrics.functional.pairwise.cosine import pairwise_cosine_similarity
+from torchmetrics.functional.pairwise.euclidean import pairwise_euclidean_distance
+from torchmetrics.functional.pairwise.linear import pairwise_linear_similarity
+from torchmetrics.functional.pairwise.manhattan import pairwise_manhattan_distance
+from torchmetrics.functional.pairwise.minkowski import pairwise_minkowski_distance
+
+__all__ = [
+    "pairwise_cosine_similarity",
+    "pairwise_euclidean_distance",
+    "pairwise_linear_similarity",
+    "pairwise_manhattan_distance",
+    "pairwise_minkowski_distance",
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/pairwise/cosine.py

@@ -0,0 +1,91 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.pairwise.helpers import _check_input, _reduce_distance_matrix
+from torchmetrics.utilities.compute import _safe_matmul
+
+
+def _pairwise_cosine_similarity_update(
+    x: Tensor, y: Optional[Tensor] = None, zero_diagonal: Optional[bool] = None
+) -> Tensor:
+    """Calculate the pairwise cosine similarity matrix.
+
+    Args:
+        x: tensor of shape ``[N,d]``
+        y: tensor of shape ``[M,d]``
+        zero_diagonal: determines if the diagonal of the distance matrix should be set to zero
+
+    """
+    x, y, zero_diagonal = _check_input(x, y, zero_diagonal)
+
+    norm = torch.norm(x, p=2, dim=1)
+    x = x / norm.unsqueeze(1)
+    norm = torch.norm(y, p=2, dim=1)
+    y = y / norm.unsqueeze(1)
+
+    distance = _safe_matmul(x, y)
+    if zero_diagonal:
+        distance.fill_diagonal_(0)
+    return distance
+
+
+def pairwise_cosine_similarity(
+    x: Tensor,
+    y: Optional[Tensor] = None,
+    reduction: Literal["mean", "sum", "none", None] = None,
+    zero_diagonal: Optional[bool] = None,
+) -> Tensor:
+    r"""Calculate pairwise cosine similarity.
+
+    .. math::
+        s_{cos}(x,y) = \frac{<x,y>}{||x|| \cdot ||y||}
+                     = \frac{\sum_{d=1}^D x_d \cdot y_d }{\sqrt{\sum_{d=1}^D x_i^2} \cdot \sqrt{\sum_{d=1}^D y_i^2}}
+
+    If both :math:`x` and :math:`y` are passed in, the calculation will be performed pairwise
+    between the rows of :math:`x` and :math:`y`.
+    If only :math:`x` is passed in, the calculation will be performed between the rows of :math:`x`.
+
+    Args:
+        x: Tensor with shape ``[N, d]``
+        y: Tensor with shape ``[M, d]``, optional
+        reduction: reduction to apply along the last dimension. Choose between `'mean'`, `'sum'`
+            (applied along column dimension) or  `'none'`, `None` for no reduction
+        zero_diagonal: if the diagonal of the distance matrix should be set to 0. If only :math:`x` is given
+            this defaults to ``True`` else if :math:`y` is also given it defaults to ``False``
+
+    Returns:
+        A ``[N,N]`` matrix of distances if only ``x`` is given, else a ``[N,M]`` matrix
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.pairwise import pairwise_cosine_similarity
+        >>> x = torch.tensor([[2, 3], [3, 5], [5, 8]], dtype=torch.float32)
+        >>> y = torch.tensor([[1, 0], [2, 1]], dtype=torch.float32)
+        >>> pairwise_cosine_similarity(x, y)
+        tensor([[0.5547, 0.8682],
+                [0.5145, 0.8437],
+                [0.5300, 0.8533]])
+        >>> pairwise_cosine_similarity(x)
+        tensor([[0.0000, 0.9989, 0.9996],
+                [0.9989, 0.0000, 0.9998],
+                [0.9996, 0.9998, 0.0000]])
+
+    """
+    distance = _pairwise_cosine_similarity_update(x, y, zero_diagonal)
+    return _reduce_distance_matrix(distance, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/pairwise/euclidean.py

@@ -0,0 +1,89 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.pairwise.helpers import _check_input, _reduce_distance_matrix
+
+
+def _pairwise_euclidean_distance_update(
+    x: Tensor, y: Optional[Tensor] = None, zero_diagonal: Optional[bool] = None
+) -> Tensor:
+    """Calculate the pairwise euclidean distance matrix.
+
+    Args:
+        x: tensor of shape ``[N,d]``
+        y: tensor of shape ``[M,d]``
+        zero_diagonal: determines if the diagonal of the distance matrix should be set to zero
+
+    """
+    x, y, zero_diagonal = _check_input(x, y, zero_diagonal)
+    # upcast to float64 to prevent precision issues
+    _orig_dtype = x.dtype
+    x = x.to(torch.float64)
+    y = y.to(torch.float64)
+    x_norm = (x * x).sum(dim=1, keepdim=True)
+    y_norm = (y * y).sum(dim=1)
+    distance = (x_norm + y_norm - 2 * x.mm(y.T)).to(_orig_dtype)
+    if zero_diagonal:
+        distance.fill_diagonal_(0)
+    return distance.sqrt()
+
+
+def pairwise_euclidean_distance(
+    x: Tensor,
+    y: Optional[Tensor] = None,
+    reduction: Literal["mean", "sum", "none", None] = None,
+    zero_diagonal: Optional[bool] = None,
+) -> Tensor:
+    r"""Calculate pairwise euclidean distances.
+
+    .. math::
+        d_{euc}(x,y) = ||x - y||_2 = \sqrt{\sum_{d=1}^D (x_d - y_d)^2}
+
+    If both :math:`x` and :math:`y` are passed in, the calculation will be performed pairwise between
+    the rows of :math:`x` and :math:`y`.
+    If only :math:`x` is passed in, the calculation will be performed between the rows of :math:`x`.
+
+    Args:
+        x: Tensor with shape ``[N, d]``
+        y: Tensor with shape ``[M, d]``, optional
+        reduction: reduction to apply along the last dimension. Choose between `'mean'`, `'sum'`
+            (applied along column dimension) or  `'none'`, `None` for no reduction
+        zero_diagonal: if the diagonal of the distance matrix should be set to 0. If only `x` is given
+            this defaults to `True` else if `y` is also given it defaults to `False`
+
+    Returns:
+        A ``[N,N]`` matrix of distances if only ``x`` is given, else a ``[N,M]`` matrix
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.pairwise import pairwise_euclidean_distance
+        >>> x = torch.tensor([[2, 3], [3, 5], [5, 8]], dtype=torch.float32)
+        >>> y = torch.tensor([[1, 0], [2, 1]], dtype=torch.float32)
+        >>> pairwise_euclidean_distance(x, y)
+        tensor([[3.1623, 2.0000],
+                [5.3852, 4.1231],
+                [8.9443, 7.6158]])
+        >>> pairwise_euclidean_distance(x)
+        tensor([[0.0000, 2.2361, 5.8310],
+                [2.2361, 0.0000, 3.6056],
+                [5.8310, 3.6056, 0.0000]])
+
+    """
+    distance = _pairwise_euclidean_distance_update(x, y, zero_diagonal)
+    return _reduce_distance_matrix(distance, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/pairwise/helpers.py

@@ -0,0 +1,60 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+from torch import Tensor
+
+
+def _check_input(
+    x: Tensor, y: Optional[Tensor] = None, zero_diagonal: Optional[bool] = None
+) -> tuple[Tensor, Tensor, bool]:
+    """Check that input has the right dimensionality and sets the ``zero_diagonal`` argument if user has not set it.
+
+    Args:
+        x: tensor of shape ``[N,d]``
+        y: if provided, a tensor of shape ``[M,d]``
+        zero_diagonal: determines if the diagonal of the distance matrix should be set to zero
+
+    """
+    if x.ndim != 2:
+        raise ValueError(f"Expected argument `x` to be a 2D tensor of shape `[N, d]` but got {x.shape}")
+
+    if y is not None:
+        if y.ndim != 2 or y.shape[1] != x.shape[1]:
+            raise ValueError(
+                "Expected argument `y` to be a 2D tensor of shape `[M, d]` where"
+                " `d` should be same as the last dimension of `x`"
+            )
+        zero_diagonal = False if zero_diagonal is None else zero_diagonal
+    else:
+        y = x.clone()
+        zero_diagonal = True if zero_diagonal is None else zero_diagonal
+    return x, y, zero_diagonal
+
+
+def _reduce_distance_matrix(distmat: Tensor, reduction: Optional[str] = None) -> Tensor:
+    """Reduction of distance matrix.
+
+    Args:
+        distmat: a ``[N,M]`` matrix
+        reduction: string determining how to reduce along last dimension
+
+    """
+    if reduction == "mean":
+        return distmat.mean(dim=-1)
+    if reduction == "sum":
+        return distmat.sum(dim=-1)
+    if reduction is None or reduction == "none":
+        return distmat
+    raise ValueError(f"Expected reduction to be one of `['mean', 'sum', None]` but got {reduction}")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/pairwise/linear.py

@@ -0,0 +1,84 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.pairwise.helpers import _check_input, _reduce_distance_matrix
+from torchmetrics.utilities.compute import _safe_matmul
+
+
+def _pairwise_linear_similarity_update(
+    x: Tensor, y: Optional[Tensor] = None, zero_diagonal: Optional[bool] = None
+) -> Tensor:
+    """Calculate the pairwise linear similarity matrix.
+
+    Args:
+        x: tensor of shape ``[N,d]``
+        y: tensor of shape ``[M,d]``
+        zero_diagonal: determines if the diagonal of the distance matrix should be set to zero
+
+    """
+    x, y, zero_diagonal = _check_input(x, y, zero_diagonal)
+
+    distance = _safe_matmul(x, y)
+    if zero_diagonal:
+        distance.fill_diagonal_(0)
+    return distance
+
+
+def pairwise_linear_similarity(
+    x: Tensor,
+    y: Optional[Tensor] = None,
+    reduction: Literal["mean", "sum", "none", None] = None,
+    zero_diagonal: Optional[bool] = None,
+) -> Tensor:
+    r"""Calculate pairwise linear similarity.
+
+    .. math::
+        s_{lin}(x,y) = <x,y> = \sum_{d=1}^D x_d \cdot y_d
+
+    If both :math:`x` and :math:`y` are passed in, the calculation will be performed pairwise between
+    the rows of :math:`x` and :math:`y`.
+    If only :math:`x` is passed in, the calculation will be performed between the rows of :math:`x`.
+
+    Args:
+        x: Tensor with shape ``[N, d]``
+        y: Tensor with shape ``[M, d]``, optional
+        reduction: reduction to apply along the last dimension. Choose between `'mean'`, `'sum'`
+            (applied along column dimension) or  `'none'`, `None` for no reduction
+        zero_diagonal: if the diagonal of the distance matrix should be set to 0. If only `x` is given
+            this defaults to `True` else if `y` is also given it defaults to `False`
+
+    Returns:
+        A ``[N,N]`` matrix of distances if only ``x`` is given, else a ``[N,M]`` matrix
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.pairwise import pairwise_linear_similarity
+        >>> x = torch.tensor([[2, 3], [3, 5], [5, 8]], dtype=torch.float32)
+        >>> y = torch.tensor([[1, 0], [2, 1]], dtype=torch.float32)
+        >>> pairwise_linear_similarity(x, y)
+        tensor([[ 2.,  7.],
+                [ 3., 11.],
+                [ 5., 18.]])
+        >>> pairwise_linear_similarity(x)
+        tensor([[ 0., 21., 34.],
+                [21.,  0., 55.],
+                [34., 55.,  0.]])
+
+    """
+    distance = _pairwise_linear_similarity_update(x, y, zero_diagonal)
+    return _reduce_distance_matrix(distance, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/pairwise/manhattan.py

@@ -0,0 +1,83 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.pairwise.helpers import _check_input, _reduce_distance_matrix
+
+
+def _pairwise_manhattan_distance_update(
+    x: Tensor, y: Optional[Tensor] = None, zero_diagonal: Optional[bool] = None
+) -> Tensor:
+    """Calculate the pairwise manhattan similarity matrix.
+
+    Args:
+        x: tensor of shape ``[N,d]``
+        y: if provided, a tensor of shape ``[M,d]``
+        zero_diagonal: determines if the diagonal of the distance matrix should be set to zero
+
+    """
+    x, y, zero_diagonal = _check_input(x, y, zero_diagonal)
+
+    distance = (x.unsqueeze(1) - y.unsqueeze(0).repeat(x.shape[0], 1, 1)).abs().sum(dim=-1)
+    if zero_diagonal:
+        distance.fill_diagonal_(0)
+    return distance
+
+
+def pairwise_manhattan_distance(
+    x: Tensor,
+    y: Optional[Tensor] = None,
+    reduction: Literal["mean", "sum", "none", None] = None,
+    zero_diagonal: Optional[bool] = None,
+) -> Tensor:
+    r"""Calculate pairwise manhattan distance.
+
+    .. math::
+        d_{man}(x,y) = ||x-y||_1 = \sum_{d=1}^D |x_d - y_d|
+
+    If both :math:`x` and :math:`y` are passed in, the calculation will be performed pairwise between
+    the rows of :math:`x` and :math:`y`.
+    If only :math:`x` is passed in, the calculation will be performed between the rows of :math:`x`.
+
+    Args:
+        x: Tensor with shape ``[N, d]``
+        y: Tensor with shape ``[M, d]``, optional
+        reduction: reduction to apply along the last dimension. Choose between `'mean'`, `'sum'`
+            (applied along column dimension) or  `'none'`, `None` for no reduction
+        zero_diagonal: if the diagonal of the distance matrix should be set to 0. If only `x` is given
+            this defaults to `True` else if `y` is also given it defaults to `False`
+
+    Returns:
+        A ``[N,N]`` matrix of distances if only ``x`` is given, else a ``[N,M]`` matrix
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.pairwise import pairwise_manhattan_distance
+        >>> x = torch.tensor([[2, 3], [3, 5], [5, 8]], dtype=torch.float32)
+        >>> y = torch.tensor([[1, 0], [2, 1]], dtype=torch.float32)
+        >>> pairwise_manhattan_distance(x, y)
+        tensor([[ 4.,  2.],
+                [ 7.,  5.],
+                [12., 10.]])
+        >>> pairwise_manhattan_distance(x)
+        tensor([[0., 3., 8.],
+                [3., 0., 5.],
+                [8., 5., 0.]])
+
+    """
+    distance = _pairwise_manhattan_distance_update(x, y, zero_diagonal)
+    return _reduce_distance_matrix(distance, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/pairwise/minkowski.py

@@ -0,0 +1,93 @@
+# Copyright The PyTorch Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.pairwise.helpers import _check_input, _reduce_distance_matrix
+from torchmetrics.utilities.exceptions import TorchMetricsUserError
+
+
+def _pairwise_minkowski_distance_update(
+    x: Tensor, y: Optional[Tensor] = None, exponent: float = 2, zero_diagonal: Optional[bool] = None
+) -> Tensor:
+    """Calculate the pairwise minkowski distance matrix.
+
+    Args:
+        x: tensor of shape ``[N,d]``
+        y: tensor of shape ``[M,d]``
+        exponent: int or float larger than 1, exponent to which the difference between preds and target is to be raised
+        zero_diagonal: determines if the diagonal of the distance matrix should be set to zero
+
+    """
+    x, y, zero_diagonal = _check_input(x, y, zero_diagonal)
+    if not (isinstance(exponent, (float, int)) and exponent >= 1):
+        raise TorchMetricsUserError(f"Argument ``p`` must be a float or int greater than 1, but got {exponent}")
+    # upcast to float64 to prevent precision issues
+    _orig_dtype = x.dtype
+    x = x.to(torch.float64)
+    y = y.to(torch.float64)
+    distance = (x.unsqueeze(1) - y.unsqueeze(0)).abs().pow(exponent).sum(-1).pow(1.0 / exponent)
+    if zero_diagonal:
+        distance.fill_diagonal_(0)
+    return distance.to(_orig_dtype)
+
+
+def pairwise_minkowski_distance(
+    x: Tensor,
+    y: Optional[Tensor] = None,
+    exponent: float = 2,
+    reduction: Literal["mean", "sum", "none", None] = None,
+    zero_diagonal: Optional[bool] = None,
+) -> Tensor:
+    r"""Calculate pairwise minkowski distances.
+
+    .. math::
+        d_{minkowski}(x,y,p) = ||x - y||_p = \sqrt[p]{\sum_{d=1}^D (x_d - y_d)^p}
+
+    If both :math:`x` and :math:`y` are passed in, the calculation will be performed pairwise between the rows of
+    :math:`x` and :math:`y`. If only :math:`x` is passed in, the calculation will be performed between the rows
+    of :math:`x`.
+
+    Args:
+        x: Tensor with shape ``[N, d]``
+        y: Tensor with shape ``[M, d]``, optional
+        exponent: int or float larger than 1, exponent to which the difference between preds and target is to be raised
+        reduction: reduction to apply along the last dimension. Choose between `'mean'`, `'sum'`
+            (applied along column dimension) or  `'none'`, `None` for no reduction
+        zero_diagonal: if the diagonal of the distance matrix should be set to 0. If only `x` is given
+            this defaults to `True` else if `y` is also given it defaults to `False`
+
+    Returns:
+        A ``[N,N]`` matrix of distances if only ``x`` is given, else a ``[N,M]`` matrix
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.pairwise import pairwise_minkowski_distance
+        >>> x = torch.tensor([[2, 3], [3, 5], [5, 8]], dtype=torch.float32)
+        >>> y = torch.tensor([[1, 0], [2, 1]], dtype=torch.float32)
+        >>> pairwise_minkowski_distance(x, y, exponent=4)
+        tensor([[3.0092, 2.0000],
+                [5.0317, 4.0039],
+                [8.1222, 7.0583]])
+        >>> pairwise_minkowski_distance(x, exponent=4)
+        tensor([[0.0000, 2.0305, 5.1547],
+                [2.0305, 0.0000, 3.1383],
+                [5.1547, 3.1383, 0.0000]])
+
+    """
+    distance = _pairwise_minkowski_distance_update(x, y, exponent, zero_diagonal)
+    return _reduce_distance_matrix(distance, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/__init__.py

@@ -0,0 +1,61 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from torchmetrics.functional.regression.concordance import concordance_corrcoef
+from torchmetrics.functional.regression.cosine_similarity import cosine_similarity
+from torchmetrics.functional.regression.crps import continuous_ranked_probability_score
+from torchmetrics.functional.regression.csi import critical_success_index
+from torchmetrics.functional.regression.explained_variance import explained_variance
+from torchmetrics.functional.regression.js_divergence import jensen_shannon_divergence
+from torchmetrics.functional.regression.kendall import kendall_rank_corrcoef
+from torchmetrics.functional.regression.kl_divergence import kl_divergence
+from torchmetrics.functional.regression.log_cosh import log_cosh_error
+from torchmetrics.functional.regression.log_mse import mean_squared_log_error
+from torchmetrics.functional.regression.mae import mean_absolute_error
+from torchmetrics.functional.regression.mape import mean_absolute_percentage_error
+from torchmetrics.functional.regression.minkowski import minkowski_distance
+from torchmetrics.functional.regression.mse import mean_squared_error
+from torchmetrics.functional.regression.nrmse import normalized_root_mean_squared_error
+from torchmetrics.functional.regression.pearson import pearson_corrcoef
+from torchmetrics.functional.regression.r2 import r2_score
+from torchmetrics.functional.regression.rse import relative_squared_error
+from torchmetrics.functional.regression.spearman import spearman_corrcoef
+from torchmetrics.functional.regression.symmetric_mape import symmetric_mean_absolute_percentage_error
+from torchmetrics.functional.regression.tweedie_deviance import tweedie_deviance_score
+from torchmetrics.functional.regression.wmape import weighted_mean_absolute_percentage_error
+
+__all__ = [
+    "concordance_corrcoef",
+    "continuous_ranked_probability_score",
+    "cosine_similarity",
+    "critical_success_index",
+    "explained_variance",
+    "jensen_shannon_divergence",
+    "kendall_rank_corrcoef",
+    "kl_divergence",
+    "log_cosh_error",
+    "mean_absolute_error",
+    "mean_absolute_percentage_error",
+    "mean_absolute_percentage_error",
+    "mean_squared_error",
+    "mean_squared_log_error",
+    "minkowski_distance",
+    "normalized_root_mean_squared_error",
+    "pearson_corrcoef",
+    "r2_score",
+    "relative_squared_error",
+    "spearman_corrcoef",
+    "symmetric_mean_absolute_percentage_error",
+    "tweedie_deviance_score",
+    "weighted_mean_absolute_percentage_error",
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/concordance.py

@@ -0,0 +1,83 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+from torch import Tensor
+
+from torchmetrics.functional.regression.pearson import _pearson_corrcoef_compute, _pearson_corrcoef_update
+
+
+def _concordance_corrcoef_compute(
+    max_abs_dev_x: Tensor,
+    max_abs_dev_y: Tensor,
+    mean_x: Tensor,
+    mean_y: Tensor,
+    var_x: Tensor,
+    var_y: Tensor,
+    corr_xy: Tensor,
+    nb: Tensor,
+) -> Tensor:
+    """Compute the final concordance correlation coefficient based on accumulated statistics."""
+    pearson = _pearson_corrcoef_compute(max_abs_dev_x, max_abs_dev_y, var_x, var_y, corr_xy, nb)
+    var_x = var_x / (nb - 1)
+    var_y = var_y / (nb - 1)
+    return 2.0 * pearson * var_x.sqrt() * var_y.sqrt() / (var_x + var_y + (mean_x - mean_y) ** 2)
+
+
+def concordance_corrcoef(preds: Tensor, target: Tensor) -> Tensor:
+    r"""Compute concordance correlation coefficient that measures the agreement between two variables.
+
+    .. math::
+        \rho_c = \frac{2 \rho \sigma_x \sigma_y}{\sigma_x^2 + \sigma_y^2 + (\mu_x - \mu_y)^2}
+
+    where :math:`\mu_x, \mu_y` is the means for the two variables, :math:`\sigma_x^2, \sigma_y^2` are the corresponding
+    variances and \rho is the pearson correlation coefficient between the two variables.
+
+    Args:
+        preds: estimated scores
+        target: ground truth scores
+
+    Example (single output regression):
+        >>> from torchmetrics.functional.regression import concordance_corrcoef
+        >>> target = torch.tensor([3, -0.5, 2, 7])
+        >>> preds = torch.tensor([2.5, 0.0, 2, 8])
+        >>> concordance_corrcoef(preds, target)
+        tensor([0.9777])
+
+    Example (multi output regression):
+        >>> from torchmetrics.functional.regression import concordance_corrcoef
+        >>> target = torch.tensor([[3, -0.5], [2, 7]])
+        >>> preds = torch.tensor([[2.5, 0.0], [2, 8]])
+        >>> concordance_corrcoef(preds, target)
+        tensor([0.7273, 0.9887])
+
+    """
+    d = preds.shape[1] if preds.ndim == 2 else 1
+    _temp = torch.zeros(d, dtype=preds.dtype, device=preds.device)
+    mean_x, mean_y, var_x = _temp.clone(), _temp.clone(), _temp.clone()
+    var_y, corr_xy, nb = _temp.clone(), _temp.clone(), _temp.clone()
+    max_abs_dev_x, max_abs_dev_y = _temp.clone(), _temp.clone()
+    mean_x, mean_y, max_abs_dev_x, max_abs_dev_y, var_x, var_y, corr_xy, nb = _pearson_corrcoef_update(
+        preds=preds,
+        target=target,
+        mean_x=mean_x,
+        mean_y=mean_y,
+        max_abs_dev_x=max_abs_dev_x,
+        max_abs_dev_y=max_abs_dev_y,
+        var_x=var_x,
+        var_y=var_y,
+        corr_xy=corr_xy,
+        num_prior=nb,
+        num_outputs=1 if preds.ndim == 1 else preds.shape[-1],
+    )
+    return _concordance_corrcoef_compute(max_abs_dev_x, max_abs_dev_y, mean_x, mean_y, var_x, var_y, corr_xy, nb)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/cosine_similarity.py

@@ -0,0 +1,101 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _cosine_similarity_update(
+    preds: Tensor,
+    target: Tensor,
+) -> tuple[Tensor, Tensor]:
+    """Update and returns variables required to compute Cosine Similarity. Checks for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+
+    """
+    _check_same_shape(preds, target)
+    if preds.ndim != 2:
+        raise ValueError(
+            "Expected input to cosine similarity to be 2D tensors of shape `[N,D]` where `N` is the number of samples"
+            f" and `D` is the number of dimensions, but got tensor of shape {preds.shape}"
+        )
+    preds = preds.float()
+    target = target.float()
+
+    return preds, target
+
+
+def _cosine_similarity_compute(preds: Tensor, target: Tensor, reduction: Optional[str] = "sum") -> Tensor:
+    """Compute Cosine Similarity.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        reduction:
+            The method of reducing along the batch dimension using sum, mean or taking the individual scores
+
+    Example:
+        >>> target = torch.tensor([[1, 2, 3, 4], [1, 2, 3, 4]])
+        >>> preds = torch.tensor([[1, 2, 3, 4], [-1, -2, -3, -4]])
+        >>> preds, target = _cosine_similarity_update(preds, target)
+        >>> _cosine_similarity_compute(preds, target, 'none')
+        tensor([ 1.0000, -1.0000])
+
+    """
+    dot_product = (preds * target).sum(dim=-1)
+    preds_norm = preds.norm(dim=-1)
+    target_norm = target.norm(dim=-1)
+    similarity = dot_product / (preds_norm * target_norm)
+    reduction_mapping = {
+        "sum": torch.sum,
+        "mean": torch.mean,
+        "none": lambda x: x,
+        None: lambda x: x,
+    }
+    return reduction_mapping[reduction](similarity)  # type: ignore[operator]
+
+
+def cosine_similarity(preds: Tensor, target: Tensor, reduction: Optional[str] = "sum") -> Tensor:
+    r"""Compute the `Cosine Similarity`_.
+
+    .. math::
+        cos_{sim}(x,y) = \frac{x \cdot y}{||x|| \cdot ||y||} =
+        \frac{\sum_{i=1}^n x_i y_i}{\sqrt{\sum_{i=1}^n x_i^2}\sqrt{\sum_{i=1}^n y_i^2}}
+
+    where :math:`y` is a tensor of target values, and :math:`x` is a tensor of predictions.
+
+    Args:
+        preds: Predicted tensor with shape ``(N,d)``
+        target: Ground truth tensor with shape ``(N,d)``
+        reduction:
+            The method of reducing along the batch dimension using sum, mean or taking the individual scores
+
+    Example:
+        >>> from torchmetrics.functional.regression import cosine_similarity
+        >>> target = torch.tensor([[1, 2, 3, 4],
+        ...                        [1, 2, 3, 4]])
+        >>> preds = torch.tensor([[1, 2, 3, 4],
+        ...                       [-1, -2, -3, -4]])
+        >>> cosine_similarity(preds, target, 'none')
+        tensor([ 1.0000, -1.0000])
+
+    """
+    preds, target = _cosine_similarity_update(preds, target)
+    return _cosine_similarity_compute(preds, target, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/crps.py

@@ -0,0 +1,99 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Tuple
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _crps_update(preds: Tensor, target: Tensor) -> Tuple[int, Tensor, Tensor]:
+    """Compute intermediate CRPS values before aggregation.
+
+    Args:
+        preds: Tensor of shape (batch_size, ensemble_members)
+        target: Tensor of shape (batch_size,)
+
+    Returns:
+        batch_size: int
+        diff: Tensor (batch-wise absolute error term)
+        ensemble_sum: Tensor (pairwise ensemble term)
+
+    """
+    # Only second dimension should deviate in shape (the ensemble members)
+    _check_same_shape(preds[:, 0], target)
+
+    batch_size, n_ensemble_members = preds.shape
+    if n_ensemble_members < 2:
+        raise ValueError(f"CRPS requires at least 2 ensemble members, but you provided {preds.shape}.")
+
+    # sort forecasts
+    preds = torch.sort(preds, dim=1)[0]
+
+    # inflate observations:
+    observation_inflated = target.unsqueeze(1).expand_as(preds)
+
+    # Compute mean absolute difference between predictions and target
+    diff = torch.sum(torch.abs(preds - observation_inflated), dim=1) / n_ensemble_members
+
+    # Compute ensemble term using the reference implementation formula
+    ensemble_diffs = torch.abs(preds.unsqueeze(2) - preds.unsqueeze(1))
+    ensemble_sum = torch.sum(ensemble_diffs, dim=(1, 2)) / (2 * n_ensemble_members * n_ensemble_members)
+
+    return batch_size, diff, ensemble_sum
+
+
+def _crps_compute(batch_size: int, diff: Tensor, ensemble_sum: Tensor) -> Tensor:
+    """Final CRPS computation."""
+    return torch.mean(diff - ensemble_sum)  # Changed from sum to mean
+
+
+def continuous_ranked_probability_score(preds: Tensor, target: Tensor) -> Tensor:
+    r"""Computes continuous ranked probability score.
+
+    .. math::
+        CRPS(F, y) = \int_{-\infty}^{\infty} (F(x) - 1_{x \geq y})^2 dx
+
+    where :math:`F` is the predicted cumulative distribution function and :math:`y` is the true target. The metric is
+    usually used to evaluate probabilistic regression models, such as forecasting models. A lower CRPS indicates a
+    better forecast, meaning that forecasted probabilities are closer to the true observed values. CRPS can also be
+    seen as a generalization of the brier score for non binary classification problems.
+
+    Args:
+        preds: a 2d tensor of shape (batch_size, ensemble_members) with predictions. The second dimension represents
+            the ensemble members.
+        target: a 1d tensor of shape (batch_size) with the target values.
+
+    Return:
+        Tensor with CRPS
+
+    Raises:
+        ValueError:
+            If the number of ensemble members is less than 2.
+        ValueError:
+            If the first dimension of preds and target do not match.
+
+    Example::
+        >>> from torchmetrics.functional.regression import continuous_ranked_probability_score
+        >>> from torch import randn
+        >>> preds = randn(10, 5)
+        >>> target = randn(10)
+        >>> continuous_ranked_probability_score(preds, target)
+        tensor(0.7731)
+
+    """
+    batch_size, diff, ensemble_sum = _crps_update(preds, target)
+    return _crps_compute(batch_size, diff, ensemble_sum)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/csi.py

@@ -0,0 +1,112 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.compute import _safe_divide
+
+
+def _critical_success_index_update(
+    preds: Tensor, target: Tensor, threshold: float, keep_sequence_dim: Optional[int] = None
+) -> tuple[Tensor, Tensor, Tensor]:
+    """Update and return variables required to compute Critical Success Index. Checks for same shape of tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        threshold: Values above or equal to threshold are replaced with 1, below by 0
+        keep_sequence_dim: Index of the sequence dimension if the inputs are sequences of images. If specified,
+            the score will be calculated separately for each image in the sequence. If ``None``, the score will be
+            calculated across all dimensions.
+
+    """
+    _check_same_shape(preds, target)
+
+    if keep_sequence_dim is None:
+        sum_dims = None
+    elif not 0 <= keep_sequence_dim < preds.ndim:
+        raise ValueError(f"Expected keep_sequence dim to be in range [0, {preds.ndim}] but got {keep_sequence_dim}")
+    else:
+        sum_dims = tuple(i for i in range(preds.ndim) if i != keep_sequence_dim)
+
+    # binarize the tensors with the threshold
+    preds_bin = (preds >= threshold).bool()
+    target_bin = (target >= threshold).bool()
+
+    if keep_sequence_dim is None:
+        hits = torch.sum(preds_bin & target_bin).int()
+        misses = torch.sum((preds_bin ^ target_bin) & target_bin).int()
+        false_alarms = torch.sum((preds_bin ^ target_bin) & preds_bin).int()
+    else:
+        hits = torch.sum(preds_bin & target_bin, dim=sum_dims).int()
+        misses = torch.sum((preds_bin ^ target_bin) & target_bin, dim=sum_dims).int()
+        false_alarms = torch.sum((preds_bin ^ target_bin) & preds_bin, dim=sum_dims).int()
+    return hits, misses, false_alarms
+
+
+def _critical_success_index_compute(hits: Tensor, misses: Tensor, false_alarms: Tensor) -> Tensor:
+    """Compute critical success index.
+
+    Args:
+        hits: Number of true positives after binarization
+        misses: Number of false negatives after binarization
+        false_alarms: Number of false positives after binarization
+
+    Returns:
+        If input tensors are 5-dimensional and ``keep_sequence_dim=True``, the metric returns a ``(S,)`` vector
+        with CSI scores for each image in the sequence. Otherwise, it returns a scalar tensor with the CSI score.
+
+    """
+    return _safe_divide(hits, hits + misses + false_alarms)
+
+
+def critical_success_index(
+    preds: Tensor, target: Tensor, threshold: float, keep_sequence_dim: Optional[int] = None
+) -> Tensor:
+    """Compute critical success index.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        threshold: Values above or equal to threshold are replaced with 1, below by 0
+        keep_sequence_dim: Index of the sequence dimension if the inputs are sequences of images. If specified,
+            the score will be calculated separately for each image in the sequence. If ``None``, the score will be
+            calculated across all dimensions.
+
+    Returns:
+        If ``keep_sequence_dim`` is specified, the metric returns a vector of  with CSI scores for each image
+        in the sequence. Otherwise, it returns a scalar tensor with the CSI score.
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.regression import critical_success_index
+        >>> x = torch.Tensor([[0.2, 0.7], [0.9, 0.3]])
+        >>> y = torch.Tensor([[0.4, 0.2], [0.8, 0.6]])
+        >>> critical_success_index(x, y, 0.5)
+        tensor(0.3333)
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.regression import critical_success_index
+        >>> x = torch.Tensor([[[0.2, 0.7], [0.9, 0.3]], [[0.2, 0.7], [0.9, 0.3]]])
+        >>> y = torch.Tensor([[[0.4, 0.2], [0.8, 0.6]], [[0.4, 0.2], [0.8, 0.6]]])
+        >>> critical_success_index(x, y, 0.5, keep_sequence_dim=0)
+        tensor([0.3333, 0.3333])
+
+    """
+    hits, misses, false_alarms = _critical_success_index_update(preds, target, threshold, keep_sequence_dim)
+    return _critical_success_index_compute(hits, misses, false_alarms)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/explained_variance.py

@@ -0,0 +1,142 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections.abc import Sequence
+from typing import Union
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+ALLOWED_MULTIOUTPUT = ("raw_values", "uniform_average", "variance_weighted")
+
+
+def _explained_variance_update(preds: Tensor, target: Tensor) -> tuple[int, Tensor, Tensor, Tensor, Tensor]:
+    """Update and returns variables required to compute Explained Variance. Checks for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+
+    """
+    _check_same_shape(preds, target)
+
+    num_obs = preds.size(0)
+    sum_error = torch.sum(target - preds, dim=0)
+    diff = target - preds
+    sum_squared_error = torch.sum(diff * diff, dim=0)
+
+    sum_target = torch.sum(target, dim=0)
+    sum_squared_target = torch.sum(target * target, dim=0)
+
+    return num_obs, sum_error, sum_squared_error, sum_target, sum_squared_target
+
+
+def _explained_variance_compute(
+    num_obs: Union[int, Tensor],
+    sum_error: Tensor,
+    sum_squared_error: Tensor,
+    sum_target: Tensor,
+    sum_squared_target: Tensor,
+    multioutput: Literal["raw_values", "uniform_average", "variance_weighted"] = "uniform_average",
+) -> Tensor:
+    """Compute Explained Variance.
+
+    Args:
+        num_obs: Number of predictions or observations
+        sum_error: Sum of errors over all observations
+        sum_squared_error: Sum of square of errors over all observations
+        sum_target: Sum of target values
+        sum_squared_target: Sum of squares of target values
+        multioutput: Defines aggregation in the case of multiple output scores. Can be one
+            of the following strings:
+
+            * ``'raw_values'`` returns full set of scores
+            * ``'uniform_average'`` scores are uniformly averaged
+            * ``'variance_weighted'`` scores are weighted by their individual variances
+
+    Example:
+        >>> target = torch.tensor([[0.5, 1], [-1, 1], [7, -6]])
+        >>> preds = torch.tensor([[0, 2], [-1, 2], [8, -5]])
+        >>> num_obs, sum_error, ss_error, sum_target, ss_target = _explained_variance_update(preds, target)
+        >>> _explained_variance_compute(num_obs, sum_error, ss_error, sum_target, ss_target, multioutput='raw_values')
+        tensor([0.9677, 1.0000])
+
+    """
+    diff_avg = sum_error / num_obs
+    numerator = sum_squared_error / num_obs - (diff_avg * diff_avg)
+
+    target_avg = sum_target / num_obs
+    denominator = sum_squared_target / num_obs - (target_avg * target_avg)
+
+    # Take care of division by zero
+    nonzero_numerator = numerator != 0
+    nonzero_denominator = denominator != 0
+    valid_score = nonzero_numerator & nonzero_denominator
+    output_scores = torch.ones_like(diff_avg)
+    output_scores[valid_score] = 1.0 - (numerator[valid_score] / denominator[valid_score])
+    output_scores[nonzero_numerator & ~nonzero_denominator] = 0.0
+
+    # Decide what to do in multioutput case
+    # Todo: allow user to pass in tensor with weights
+    if multioutput == "raw_values":
+        return output_scores
+    if multioutput == "uniform_average":
+        return torch.mean(output_scores)
+    denom_sum = torch.sum(denominator)
+    return torch.sum(denominator / denom_sum * output_scores)
+
+
+def explained_variance(
+    preds: Tensor,
+    target: Tensor,
+    multioutput: Literal["raw_values", "uniform_average", "variance_weighted"] = "uniform_average",
+) -> Union[Tensor, Sequence[Tensor]]:
+    """Compute explained variance.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+        multioutput: Defines aggregation in the case of multiple output scores. Can be one
+            of the following strings):
+
+            * ``'raw_values'`` returns full set of scores
+            * ``'uniform_average'`` scores are uniformly averaged
+            * ``'variance_weighted'`` scores are weighted by their individual variances
+
+    Example:
+        >>> from torchmetrics.functional.regression import explained_variance
+        >>> target = torch.tensor([3, -0.5, 2, 7])
+        >>> preds = torch.tensor([2.5, 0.0, 2, 8])
+        >>> explained_variance(preds, target)
+        tensor(0.9572)
+
+        >>> target = torch.tensor([[0.5, 1], [-1, 1], [7, -6]])
+        >>> preds = torch.tensor([[0, 2], [-1, 2], [8, -5]])
+        >>> explained_variance(preds, target, multioutput='raw_values')
+        tensor([0.9677, 1.0000])
+
+    """
+    if multioutput not in ALLOWED_MULTIOUTPUT:
+        raise ValueError(f"Invalid input to argument `multioutput`. Choose one of the following: {ALLOWED_MULTIOUTPUT}")
+    num_obs, sum_error, sum_squared_error, sum_target, sum_squared_target = _explained_variance_update(preds, target)
+    return _explained_variance_compute(
+        num_obs,
+        sum_error,
+        sum_squared_error,
+        sum_target,
+        sum_squared_target,
+        multioutput,
+    )

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/js_divergence.py

@@ -0,0 +1,102 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Union
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.regression.kl_divergence import kl_divergence
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _jsd_update(p: Tensor, q: Tensor, log_prob: bool) -> tuple[Tensor, int]:
+    """Update and returns jensen-shannon divergence scores for each observation and the total number of observations.
+
+    Args:
+        p: data distribution with shape ``[N, d]``
+        q: prior or approximate distribution with shape ``[N, d]``
+        log_prob: bool indicating if input is log-probabilities or probabilities. If given as probabilities,
+            will normalize to make sure the distributes sum to 1
+
+    """
+    _check_same_shape(p, q)
+    if p.ndim != 2 or q.ndim != 2:
+        raise ValueError(f"Expected both p and q distribution to be 2D but got {p.ndim} and {q.ndim} respectively")
+
+    total = p.shape[0]
+    if log_prob:
+        mean = torch.logsumexp(torch.stack([p, q]), dim=0) - torch.log(torch.tensor(2.0))
+        measures = 0.5 * kl_divergence(p, mean, log_prob=log_prob, reduction=None) + 0.5 * kl_divergence(
+            q, mean, log_prob=log_prob, reduction=None
+        )
+    else:
+        p = p / p.sum(axis=-1, keepdim=True)  # type: ignore[call-overload]
+        q = q / q.sum(axis=-1, keepdim=True)  # type: ignore[call-overload]
+        mean = (p + q) / 2
+        measures = 0.5 * kl_divergence(p, mean, log_prob=log_prob, reduction=None) + 0.5 * kl_divergence(
+            q, mean, log_prob=log_prob, reduction=None
+        )
+    return measures, total
+
+
+def _jsd_compute(
+    measures: Tensor, total: Union[int, Tensor], reduction: Literal["mean", "sum", "none", None] = "mean"
+) -> Tensor:
+    """Compute and reduce the Jensen-Shannon divergence based on the type of reduction."""
+    if reduction == "sum":
+        return measures.sum()
+    if reduction == "mean":
+        return measures.sum() / total
+    if reduction is None or reduction == "none":
+        return measures
+    return measures / total
+
+
+def jensen_shannon_divergence(
+    p: Tensor, q: Tensor, log_prob: bool = False, reduction: Literal["mean", "sum", "none", None] = "mean"
+) -> Tensor:
+    r"""Compute `Jensen-Shannon divergence`_.
+
+    .. math::
+        D_{JS}(P||Q) = \frac{1}{2} D_{KL}(P||M) + \frac{1}{2} D_{KL}(Q||M)
+
+    Where :math:`P` and :math:`Q` are probability distributions where :math:`P` usually represents a distribution
+    over data and :math:`Q` is often a prior or approximation of :math:`P`. :math:`D_{KL}` is the `KL divergence`_ and
+    :math:`M` is the average of the two distributions. It should be noted that the Jensen-Shannon divergence is a
+    symmetrical metric i.e. :math:`D_{JS}(P||Q) = D_{JS}(Q||P)`.
+
+    Args:
+        p: data distribution with shape ``[N, d]``
+        q: prior or approximate distribution with shape ``[N, d]``
+        log_prob: bool indicating if input is log-probabilities or probabilities. If given as probabilities,
+            will normalize to make sure the distributes sum to 1
+        reduction:
+            Determines how to reduce over the ``N``/batch dimension:
+
+            - ``'mean'`` [default]: Averages score across samples
+            - ``'sum'``: Sum score across samples
+            - ``'none'`` or ``None``: Returns score per sample
+
+    Example:
+        >>> from torch import tensor
+        >>> p = tensor([[0.36, 0.48, 0.16]])
+        >>> q = tensor([[1/3, 1/3, 1/3]])
+        >>> jensen_shannon_divergence(p, q)
+        tensor(0.0225)
+
+    """
+    measures, total = _jsd_update(p, q, log_prob)
+    return _jsd_compute(measures, total, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/kendall.py

@@ -0,0 +1,430 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import List, Optional, Union
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.regression.utils import _check_data_shape_to_num_outputs
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.data import _bincount, _cumsum, dim_zero_cat
+from torchmetrics.utilities.enums import EnumStr
+
+
+class _MetricVariant(EnumStr):
+    """Enumerate for metric variants."""
+
+    A = "a"
+    B = "b"
+    C = "c"
+
+    @staticmethod
+    def _name() -> str:
+        return "variant"
+
+
+class _TestAlternative(EnumStr):
+    """Enumerate for test alternative options."""
+
+    TWO_SIDED = "two-sided"
+    LESS = "less"
+    GREATER = "greater"
+
+    @staticmethod
+    def _name() -> str:
+        return "alternative"
+
+
+def _sort_on_first_sequence(x: Tensor, y: Tensor) -> tuple[Tensor, Tensor]:
+    """Sort sequences in an ascent order according to the sequence ``x``."""
+    # We need to clone `y` tensor not to change an object in memory
+    y = torch.clone(y)
+    x, y = x.T, y.T
+    x, perm = x.sort()
+    for i in range(x.shape[0]):
+        y[i] = y[i][perm[i]]
+    return x.T, y.T
+
+
+def _concordant_element_sum(x: Tensor, y: Tensor, i: int) -> Tensor:
+    """Count a total number of concordant pairs in a single sequence."""
+    return torch.logical_and(x[i] < x[(i + 1) :], y[i] < y[(i + 1) :]).sum(0).unsqueeze(0)
+
+
+def _count_concordant_pairs(preds: Tensor, target: Tensor) -> Tensor:
+    """Count a total number of concordant pairs in given sequences."""
+    return torch.cat([_concordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)
+
+
+def _discordant_element_sum(x: Tensor, y: Tensor, i: int) -> Tensor:
+    """Count a total number of discordant pairs in a single sequences."""
+    return (
+        torch.logical_or(
+            torch.logical_and(x[i] > x[(i + 1) :], y[i] < y[(i + 1) :]),
+            torch.logical_and(x[i] < x[(i + 1) :], y[i] > y[(i + 1) :]),
+        )
+        .sum(0)
+        .unsqueeze(0)
+    )
+
+
+def _count_discordant_pairs(preds: Tensor, target: Tensor) -> Tensor:
+    """Count a total number of discordant pairs in given sequences."""
+    return torch.cat([_discordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)
+
+
+def _convert_sequence_to_dense_rank(x: Tensor, sort: bool = False) -> Tensor:
+    """Convert a sequence to the rank tensor."""
+    # Sort if a sequence has not been sorted before
+    if sort:
+        x = x.sort(dim=0).values
+    _ones = torch.zeros(1, x.shape[1], dtype=torch.int32, device=x.device)
+    return _cumsum(torch.cat([_ones, (x[1:] != x[:-1]).int()], dim=0), dim=0)
+
+
+def _get_ties(x: Tensor) -> tuple[Tensor, Tensor, Tensor]:
+    """Get a total number of ties and staistics for p-value calculation for  a given sequence."""
+    ties = torch.zeros(x.shape[1], dtype=x.dtype, device=x.device)
+    ties_p1 = torch.zeros(x.shape[1], dtype=x.dtype, device=x.device)
+    ties_p2 = torch.zeros(x.shape[1], dtype=x.dtype, device=x.device)
+    for dim in range(x.shape[1]):
+        n_ties = _bincount(x[:, dim])
+        n_ties = n_ties[n_ties > 1]
+        ties[dim] = (n_ties * (n_ties - 1) // 2).sum()
+        ties_p1[dim] = (n_ties * (n_ties - 1.0) * (n_ties - 2)).sum()
+        ties_p2[dim] = (n_ties * (n_ties - 1.0) * (2 * n_ties + 5)).sum()
+
+    return ties, ties_p1, ties_p2
+
+
+def _get_metric_metadata(
+    preds: Tensor, target: Tensor, variant: _MetricVariant
+) -> tuple[
+    Tensor,
+    Tensor,
+    Optional[Tensor],
+    Optional[Tensor],
+    Optional[Tensor],
+    Optional[Tensor],
+    Optional[Tensor],
+    Optional[Tensor],
+    Tensor,
+]:
+    """Obtain statistics to calculate metric value."""
+    preds, target = _sort_on_first_sequence(preds, target)
+
+    concordant_pairs = _count_concordant_pairs(preds, target)
+    discordant_pairs = _count_discordant_pairs(preds, target)
+
+    n_total = torch.tensor(preds.shape[0], device=preds.device)
+    preds_ties = target_ties = None
+    preds_ties_p1 = preds_ties_p2 = target_ties_p1 = target_ties_p2 = None
+    if variant != _MetricVariant.A:
+        preds = _convert_sequence_to_dense_rank(preds)
+        target = _convert_sequence_to_dense_rank(target, sort=True)
+        preds_ties, preds_ties_p1, preds_ties_p2 = _get_ties(preds)
+        target_ties, target_ties_p1, target_ties_p2 = _get_ties(target)
+    return (
+        concordant_pairs,
+        discordant_pairs,
+        preds_ties,
+        preds_ties_p1,
+        preds_ties_p2,
+        target_ties,
+        target_ties_p1,
+        target_ties_p2,
+        n_total,
+    )
+
+
+def _calculate_tau(
+    preds: Tensor,
+    target: Tensor,
+    concordant_pairs: Tensor,
+    discordant_pairs: Tensor,
+    con_min_dis_pairs: Tensor,
+    n_total: Tensor,
+    preds_ties: Optional[Tensor],
+    target_ties: Optional[Tensor],
+    variant: _MetricVariant,
+) -> Tensor:
+    """Calculate Kendall's tau from metric metadata."""
+    if variant == _MetricVariant.A:
+        return con_min_dis_pairs / (concordant_pairs + discordant_pairs)
+    if variant == _MetricVariant.B:
+        total_combinations: Tensor = n_total * (n_total - 1) // 2
+        if preds_ties is None:
+            preds_ties = torch.tensor(0.0, dtype=total_combinations.dtype, device=total_combinations.device)
+        if target_ties is None:
+            target_ties = torch.tensor(0.0, dtype=total_combinations.dtype, device=total_combinations.device)
+        denominator = (total_combinations - preds_ties) * (total_combinations - target_ties)
+        return con_min_dis_pairs / torch.sqrt(denominator)
+
+    preds_unique = torch.tensor([len(p.unique()) for p in preds.T], dtype=preds.dtype, device=preds.device)
+    target_unique = torch.tensor([len(t.unique()) for t in target.T], dtype=target.dtype, device=target.device)
+    min_classes = torch.minimum(preds_unique, target_unique)
+    return 2 * con_min_dis_pairs / ((min_classes - 1) / min_classes * n_total**2)
+
+
+def _get_p_value_for_t_value_from_dist(t_value: Tensor) -> Tensor:
+    """Obtain p-value for a given Tensor of t-values. Handle ``nan`` which cannot be passed into torch distributions.
+
+    When t-value is ``nan``, a resulted p-value should be alson ``nan``.
+
+    """
+    device = t_value
+    normal_dist = torch.distributions.normal.Normal(torch.tensor([0.0]).to(device), torch.tensor([1.0]).to(device))
+
+    is_nan = t_value.isnan()
+    t_value = t_value.nan_to_num()
+    p_value = normal_dist.cdf(t_value)
+    return p_value.where(~is_nan, torch.tensor(float("nan"), dtype=p_value.dtype, device=p_value.device))
+
+
+def _calculate_p_value(
+    con_min_dis_pairs: Tensor,
+    n_total: Tensor,
+    preds_ties: Optional[Tensor],
+    preds_ties_p1: Optional[Tensor],
+    preds_ties_p2: Optional[Tensor],
+    target_ties: Optional[Tensor],
+    target_ties_p1: Optional[Tensor],
+    target_ties_p2: Optional[Tensor],
+    variant: _MetricVariant,
+    alternative: Optional[_TestAlternative],
+) -> Tensor:
+    """Calculate p-value for Kendall's tau from metric metadata."""
+    t_value_denominator_base = n_total * (n_total - 1) * (2 * n_total + 5)
+    if variant == _MetricVariant.A:
+        t_value = 3 * con_min_dis_pairs / torch.sqrt(t_value_denominator_base / 2)
+    else:
+        m = n_total * (n_total - 1)
+        t_value_denominator: Tensor = (
+            t_value_denominator_base
+            - (preds_ties_p2 if preds_ties_p2 is not None else 0)
+            - (target_ties_p2 if target_ties_p2 is not None else 0)
+        ) / 18
+        t_value_denominator += (
+            2 * (preds_ties if preds_ties is not None else 0) * (target_ties if target_ties is not None else 0)
+        ) / m
+        t_value_denominator += (
+            (preds_ties_p1 if preds_ties_p1 is not None else 0)
+            * (target_ties_p1 if target_ties_p1 is not None else 0)
+            / (9 * m * (n_total - 2))
+        )
+        t_value = con_min_dis_pairs / torch.sqrt(t_value_denominator)
+
+    if alternative == _TestAlternative.TWO_SIDED:
+        t_value = torch.abs(t_value)
+    if alternative in [_TestAlternative.TWO_SIDED, _TestAlternative.GREATER]:
+        t_value *= -1
+    p_value = _get_p_value_for_t_value_from_dist(t_value)
+    if alternative == _TestAlternative.TWO_SIDED:
+        p_value *= 2
+    return p_value
+
+
+def _kendall_corrcoef_update(
+    preds: Tensor,
+    target: Tensor,
+    concat_preds: Optional[List[Tensor]] = None,
+    concat_target: Optional[List[Tensor]] = None,
+    num_outputs: int = 1,
+) -> tuple[List[Tensor], List[Tensor]]:
+    """Update variables required to compute Kendall rank correlation coefficient.
+
+    Args:
+        preds: Sequence of data
+        target: Sequence of data
+        concat_preds: List of batches of preds sequence to be concatenated
+        concat_target: List of batches of target sequence to be concatenated
+        num_outputs: Number of outputs in multioutput setting
+
+    Raises:
+        RuntimeError: If ``preds`` and ``target`` do not have the same shape
+
+    """
+    concat_preds = concat_preds or []
+    concat_target = concat_target or []
+    # Data checking
+    _check_same_shape(preds, target)
+    _check_data_shape_to_num_outputs(preds, target, num_outputs)
+
+    if num_outputs == 1:
+        preds = preds.unsqueeze(1)
+        target = target.unsqueeze(1)
+
+    concat_preds.append(preds)
+    concat_target.append(target)
+
+    return concat_preds, concat_target
+
+
+def _kendall_corrcoef_compute(
+    preds: Tensor,
+    target: Tensor,
+    variant: _MetricVariant,
+    alternative: Optional[_TestAlternative] = None,
+) -> tuple[Tensor, Optional[Tensor]]:
+    """Compute Kendall rank correlation coefficient, and optionally p-value of corresponding statistical test.
+
+    Args:
+        Args:
+        preds: Sequence of data
+        target: Sequence of data
+        variant: Indication of which variant of Kendall's tau to be used
+        alternative: Alternative hypothesis for for t-test. Possible values:
+            - 'two-sided': the rank correlation is nonzero
+            - 'less': the rank correlation is negative (less than zero)
+            - 'greater':  the rank correlation is positive (greater than zero)
+
+    """
+    (
+        concordant_pairs,
+        discordant_pairs,
+        preds_ties,
+        preds_ties_p1,
+        preds_ties_p2,
+        target_ties,
+        target_ties_p1,
+        target_ties_p2,
+        n_total,
+    ) = _get_metric_metadata(preds, target, variant)
+    con_min_dis_pairs = concordant_pairs - discordant_pairs
+
+    tau = _calculate_tau(
+        preds, target, concordant_pairs, discordant_pairs, con_min_dis_pairs, n_total, preds_ties, target_ties, variant
+    )
+    p_value = (
+        _calculate_p_value(
+            con_min_dis_pairs,
+            n_total,
+            preds_ties,
+            preds_ties_p1,
+            preds_ties_p2,
+            target_ties,
+            target_ties_p1,
+            target_ties_p2,
+            variant,
+            alternative,
+        )
+        if alternative
+        else None
+    )
+
+    # Squeeze tensor if num_outputs=1
+    if tau.shape[0] == 1:
+        tau = tau.squeeze()
+        p_value = p_value.squeeze() if p_value is not None else None
+
+    return tau.clamp(-1, 1), p_value
+
+
+def kendall_rank_corrcoef(
+    preds: Tensor,
+    target: Tensor,
+    variant: Literal["a", "b", "c"] = "b",
+    t_test: bool = False,
+    alternative: Optional[Literal["two-sided", "less", "greater"]] = "two-sided",
+) -> Union[Tensor, tuple[Tensor, Tensor]]:
+    r"""Compute `Kendall Rank Correlation Coefficient`_.
+
+    .. math::
+        tau_a = \frac{C - D}{C + D}
+
+    where :math:`C` represents concordant pairs, :math:`D` stands for discordant pairs.
+
+    .. math::
+        tau_b = \frac{C - D}{\sqrt{(C + D + T_{preds}) * (C + D + T_{target})}}
+
+    where :math:`C` represents concordant pairs, :math:`D` stands for discordant pairs and :math:`T` represents
+    a total number of ties.
+
+    .. math::
+        tau_c = 2 * \frac{C - D}{n^2 * \frac{m - 1}{m}}
+
+    where :math:`C` represents concordant pairs, :math:`D` stands for discordant pairs, :math:`n` is a total number
+    of observations and :math:`m` is a ``min`` of unique values in ``preds`` and ``target`` sequence.
+
+    Definitions according to Definition according to `The Treatment of Ties in Ranking Problems`_.
+
+    Args:
+        preds: Sequence of data of either shape ``(N,)`` or ``(N,d)``
+        target: Sequence of data of either shape ``(N,)`` or ``(N,d)``
+        variant: Indication of which variant of Kendall's tau to be used
+        t_test: Indication whether to run t-test
+        alternative: Alternative hypothesis for t-test. Possible values:
+            - 'two-sided': the rank correlation is nonzero
+            - 'less': the rank correlation is negative (less than zero)
+            - 'greater':  the rank correlation is positive (greater than zero)
+
+    Return:
+        Correlation tau statistic
+        (Optional) p-value of corresponding statistical test (asymptotic)
+
+    Raises:
+        ValueError: If ``t_test`` is not of a type bool
+        ValueError: If ``t_test=True`` and ``alternative=None``
+
+    Example (single output regression):
+        >>> from torchmetrics.functional.regression import kendall_rank_corrcoef
+        >>> preds = torch.tensor([2.5, 0.0, 2, 8])
+        >>> target = torch.tensor([3, -0.5, 2, 1])
+        >>> kendall_rank_corrcoef(preds, target)
+        tensor(0.3333)
+
+    Example (multi output regression):
+        >>> from torchmetrics.functional.regression import kendall_rank_corrcoef
+        >>> preds = torch.tensor([[2.5, 0.0], [2, 8]])
+        >>> target = torch.tensor([[3, -0.5], [2, 1]])
+        >>> kendall_rank_corrcoef(preds, target)
+        tensor([1., 1.])
+
+    Example (single output regression with t-test)
+        >>> from torchmetrics.functional.regression import kendall_rank_corrcoef
+        >>> preds = torch.tensor([2.5, 0.0, 2, 8])
+        >>> target = torch.tensor([3, -0.5, 2, 1])
+        >>> kendall_rank_corrcoef(preds, target, t_test=True, alternative='two-sided')
+        (tensor(0.3333), tensor(0.4969))
+
+    Example (multi output regression with t-test):
+        >>> from torchmetrics.functional.regression import kendall_rank_corrcoef
+        >>> preds = torch.tensor([[2.5, 0.0], [2, 8]])
+        >>> target = torch.tensor([[3, -0.5], [2, 1]])
+        >>> kendall_rank_corrcoef(preds, target, t_test=True, alternative='two-sided')
+            (tensor([1., 1.]), tensor([nan, nan]))
+
+    """
+    if not isinstance(t_test, bool):
+        raise ValueError(f"Argument `t_test` is expected to be of a type `bool`, but got {type(t_test)}.")
+    if t_test and alternative is None:
+        raise ValueError("Argument `alternative` is required if `t_test=True` but got `None`.")
+
+    _variant = _MetricVariant.from_str(str(variant))
+    _alternative = _TestAlternative.from_str(str(alternative)) if t_test else None
+
+    _preds, _target = _kendall_corrcoef_update(
+        preds, target, [], [], num_outputs=1 if preds.ndim == 1 else preds.shape[-1]
+    )
+    tau, p_value = _kendall_corrcoef_compute(
+        dim_zero_cat(_preds),
+        dim_zero_cat(_target),
+        _variant,  # type: ignore[arg-type]  # todo
+        _alternative,  # type: ignore[arg-type]  # todo
+    )
+
+    if p_value is not None:
+        return tau, p_value
+    return tau

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/kl_divergence.py

@@ -0,0 +1,115 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Union
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.compute import _safe_xlogy
+
+
+def _kld_update(p: Tensor, q: Tensor, log_prob: bool) -> tuple[Tensor, int]:
+    """Update and returns KL divergence scores for each observation and the total number of observations.
+
+    Args:
+        p: data distribution with shape ``[N, d]``
+        q: prior or approximate distribution with shape ``[N, d]``
+        log_prob: bool indicating if input is log-probabilities or probabilities. If given as probabilities,
+            will normalize to make sure the distributes sum to 1
+
+    """
+    _check_same_shape(p, q)
+    if p.ndim != 2 or q.ndim != 2:
+        raise ValueError(f"Expected both p and q distribution to be 2D but got {p.ndim} and {q.ndim} respectively")
+
+    total = p.shape[0]
+    if log_prob:
+        measures = torch.sum(p.exp() * (p - q), axis=-1)  # type: ignore[call-overload]
+    else:
+        p = p / p.sum(axis=-1, keepdim=True)  # type: ignore[call-overload]
+        q = q / q.sum(axis=-1, keepdim=True)  # type: ignore[call-overload]
+        measures = _safe_xlogy(p, p / q).sum(axis=-1)  # type: ignore[call-overload]
+
+    return measures, total
+
+
+def _kld_compute(
+    measures: Tensor, total: Union[int, Tensor], reduction: Literal["mean", "sum", "none", None] = "mean"
+) -> Tensor:
+    """Compute the KL divergenece based on the type of reduction.
+
+    Args:
+        measures: Tensor of KL divergence scores for each observation
+        total: Number of observations
+        reduction:
+            Determines how to reduce over the ``N``/batch dimension:
+
+            - ``'mean'`` [default]: Averages score across samples
+            - ``'sum'``: Sum score across samples
+            - ``'none'`` or ``None``: Returns score per sample
+
+    Example:
+        >>> p = torch.tensor([[0.36, 0.48, 0.16]])
+        >>> q = torch.tensor([[1/3, 1/3, 1/3]])
+        >>> measures, total = _kld_update(p, q, log_prob=False)
+        >>> _kld_compute(measures, total)
+        tensor(0.0853)
+
+    """
+    if reduction == "sum":
+        return measures.sum()
+    if reduction == "mean":
+        return measures.sum() / total
+    if reduction is None or reduction == "none":
+        return measures
+    return measures / total
+
+
+def kl_divergence(
+    p: Tensor, q: Tensor, log_prob: bool = False, reduction: Literal["mean", "sum", "none", None] = "mean"
+) -> Tensor:
+    r"""Compute `KL divergence`_.
+
+    .. math::
+        D_{KL}(P||Q) = \sum_{x\in\mathcal{X}} P(x) \log\frac{P(x)}{Q{x}}
+
+    Where :math:`P` and :math:`Q` are probability distributions where :math:`P` usually represents a distribution
+    over data and :math:`Q` is often a prior or approximation of :math:`P`. It should be noted that the KL divergence
+    is a non-symmetrical metric i.e. :math:`D_{KL}(P||Q) \neq D_{KL}(Q||P)`.
+
+    Args:
+        p: data distribution with shape ``[N, d]``
+        q: prior or approximate distribution with shape ``[N, d]``
+        log_prob: bool indicating if input is log-probabilities or probabilities. If given as probabilities,
+            will normalize to make sure the distributes sum to 1
+        reduction:
+            Determines how to reduce over the ``N``/batch dimension:
+
+            - ``'mean'`` [default]: Averages score across samples
+            - ``'sum'``: Sum score across samples
+            - ``'none'`` or ``None``: Returns score per sample
+
+    Example:
+        >>> from torch import tensor
+        >>> p = tensor([[0.36, 0.48, 0.16]])
+        >>> q = tensor([[1/3, 1/3, 1/3]])
+        >>> kl_divergence(p, q)
+        tensor(0.0853)
+
+    """
+    measures, total = _kld_update(p, q, log_prob)
+    return _kld_compute(measures, total, reduction)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/log_cosh.py

@@ -0,0 +1,95 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from torch import Tensor
+
+from torchmetrics.functional.regression.utils import _check_data_shape_to_num_outputs
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _unsqueeze_tensors(preds: Tensor, target: Tensor) -> tuple[Tensor, Tensor]:
+    if preds.ndim == 2:
+        return preds, target
+    return preds.unsqueeze(1), target.unsqueeze(1)
+
+
+def _log_cosh_error_update(preds: Tensor, target: Tensor, num_outputs: int) -> tuple[Tensor, Tensor]:
+    """Update and returns variables required to compute LogCosh error.
+
+    Check for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        num_outputs: Number of outputs in multioutput setting
+
+    Return:
+        Sum of LogCosh error over examples, and total number of examples
+
+    """
+    _check_same_shape(preds, target)
+    _check_data_shape_to_num_outputs(preds, target, num_outputs)
+
+    preds, target = _unsqueeze_tensors(preds, target)
+    diff = preds - target
+    sum_log_cosh_error = torch.log((torch.exp(diff) + torch.exp(-diff)) / 2).sum(0).squeeze()
+    num_obs = torch.tensor(target.shape[0], device=preds.device)
+    return sum_log_cosh_error, num_obs
+
+
+def _log_cosh_error_compute(sum_log_cosh_error: Tensor, num_obs: Tensor) -> Tensor:
+    """Compute Mean Squared Error.
+
+    Args:
+        sum_log_cosh_error: Sum of LogCosh errors over all observations
+        num_obs: Number of predictions or observations
+
+    """
+    return (sum_log_cosh_error / num_obs).squeeze()
+
+
+def log_cosh_error(preds: Tensor, target: Tensor) -> Tensor:
+    r"""Compute the `LogCosh Error`_.
+
+    .. math:: \text{LogCoshError} = \log\left(\frac{\exp(\hat{y} - y) + \exp(\hat{y - y})}{2}\right)
+
+    Where :math:`y` is a tensor of target values, and :math:`\hat{y}` is a tensor of predictions.
+
+    Args:
+        preds: estimated labels with shape ``(batch_size,)`` or `(batch_size, num_outputs)``
+        target: ground truth labels with shape ``(batch_size,)`` or `(batch_size, num_outputs)``
+
+    Return:
+        Tensor with LogCosh error
+
+    Example (single output regression)::
+        >>> from torchmetrics.functional.regression import log_cosh_error
+        >>> preds = torch.tensor([3.0, 5.0, 2.5, 7.0])
+        >>> target = torch.tensor([2.5, 5.0, 4.0, 8.0])
+        >>> log_cosh_error(preds, target)
+        tensor(0.3523)
+
+    Example (multi output regression)::
+        >>> from torchmetrics.functional.regression import log_cosh_error
+        >>> preds = torch.tensor([[3.0, 5.0, 1.2], [-2.1, 2.5, 7.0]])
+        >>> target = torch.tensor([[2.5, 5.0, 1.3], [0.3, 4.0, 8.0]])
+        >>> log_cosh_error(preds, target)
+        tensor([0.9176, 0.4277, 0.2194])
+
+    """
+    sum_log_cosh_error, num_obs = _log_cosh_error_update(
+        preds, target, num_outputs=1 if preds.ndim == 1 else preds.shape[-1]
+    )
+    return _log_cosh_error_compute(sum_log_cosh_error, num_obs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/log_mse.py

@@ -0,0 +1,76 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Union
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _mean_squared_log_error_update(preds: Tensor, target: Tensor) -> tuple[Tensor, int]:
+    """Return variables required to compute Mean Squared Log Error. Checks for same shape of tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+
+    """
+    _check_same_shape(preds, target)
+    sum_squared_log_error = torch.sum(torch.pow(torch.log1p(preds) - torch.log1p(target), 2))
+    return sum_squared_log_error, target.numel()
+
+
+def _mean_squared_log_error_compute(sum_squared_log_error: Tensor, num_obs: Union[int, Tensor]) -> Tensor:
+    """Compute Mean Squared Log Error.
+
+    Args:
+        sum_squared_log_error:
+            Sum of square of log errors over all observations ``(log error = log(target) - log(prediction))``
+        num_obs: Number of predictions or observations
+
+    Example:
+        >>> preds = torch.tensor([0., 1, 2, 3])
+        >>> target = torch.tensor([0., 1, 2, 2])
+        >>> sum_squared_log_error, num_obs = _mean_squared_log_error_update(preds, target)
+        >>> _mean_squared_log_error_compute(sum_squared_log_error, num_obs)
+        tensor(0.0207)
+
+    """
+    return sum_squared_log_error / num_obs
+
+
+def mean_squared_log_error(preds: Tensor, target: Tensor) -> Tensor:
+    """Compute mean squared log error.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+
+    Return:
+        Tensor with RMSLE
+
+    Example:
+        >>> from torchmetrics.functional.regression import mean_squared_log_error
+        >>> x = torch.tensor([0., 1, 2, 3])
+        >>> y = torch.tensor([0., 1, 2, 2])
+        >>> mean_squared_log_error(x, y)
+        tensor(0.0207)
+
+    .. attention::
+        Half precision is only support on GPU for this metric.
+
+    """
+    sum_squared_log_error, num_obs = _mean_squared_log_error_update(preds, target)
+    return _mean_squared_log_error_compute(sum_squared_log_error, num_obs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/mae.py

@@ -0,0 +1,81 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Union
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _mean_absolute_error_update(preds: Tensor, target: Tensor, num_outputs: int) -> tuple[Tensor, int]:
+    """Update and returns variables required to compute Mean Absolute Error.
+
+    Check for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        num_outputs: Number of outputs in multioutput setting
+
+    """
+    _check_same_shape(preds, target)
+    if num_outputs == 1:
+        preds = preds.view(-1)
+        target = target.view(-1)
+    preds = preds if preds.is_floating_point else preds.float()  # type: ignore[truthy-function] # todo
+    target = target if target.is_floating_point else target.float()  # type: ignore[truthy-function] # todo
+    sum_abs_error = torch.sum(torch.abs(preds - target), dim=0)
+    return sum_abs_error, target.shape[0]
+
+
+def _mean_absolute_error_compute(sum_abs_error: Tensor, num_obs: Union[int, Tensor]) -> Tensor:
+    """Compute Mean Absolute Error.
+
+    Args:
+        sum_abs_error: Sum of absolute value of errors over all observations
+        num_obs: Number of predictions or observations
+
+    Example:
+        >>> preds = torch.tensor([0., 1, 2, 3])
+        >>> target = torch.tensor([0., 1, 2, 2])
+        >>> sum_abs_error, num_obs = _mean_absolute_error_update(preds, target, num_outputs=1)
+        >>> _mean_absolute_error_compute(sum_abs_error, num_obs)
+        tensor(0.2500)
+
+    """
+    return sum_abs_error / num_obs
+
+
+def mean_absolute_error(preds: Tensor, target: Tensor, num_outputs: int = 1) -> Tensor:
+    """Compute mean absolute error.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+        num_outputs: Number of outputs in multioutput setting
+
+    Return:
+        Tensor with MAE
+
+    Example:
+        >>> from torchmetrics.functional.regression import mean_absolute_error
+        >>> x = torch.tensor([0., 1, 2, 3])
+        >>> y = torch.tensor([0., 1, 2, 2])
+        >>> mean_absolute_error(x, y)
+        tensor(0.2500)
+
+    """
+    sum_abs_error, num_obs = _mean_absolute_error_update(preds, target, num_outputs=num_outputs)
+    return _mean_absolute_error_compute(sum_abs_error, num_obs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/mape.py

@@ -0,0 +1,91 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Union
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _mean_absolute_percentage_error_update(
+    preds: Tensor,
+    target: Tensor,
+    epsilon: float = 1.17e-06,
+) -> tuple[Tensor, int]:
+    """Update and returns variables required to compute Mean Percentage Error.
+
+    Check for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        epsilon: Specifies the lower bound for target values. Any target value below epsilon
+            is set to epsilon (avoids ``ZeroDivisionError``).
+
+    """
+    _check_same_shape(preds, target)
+
+    abs_diff = torch.abs(preds - target)
+    abs_per_error = abs_diff / torch.clamp(torch.abs(target), min=epsilon)
+
+    sum_abs_per_error = torch.sum(abs_per_error)
+
+    num_obs = target.numel()
+
+    return sum_abs_per_error, num_obs
+
+
+def _mean_absolute_percentage_error_compute(sum_abs_per_error: Tensor, num_obs: Union[int, Tensor]) -> Tensor:
+    """Compute Mean Absolute Percentage Error.
+
+    Args:
+        sum_abs_per_error: Sum of absolute value of percentage errors over all observations
+            ``(percentage error = (target - prediction) / target)``
+        num_obs: Number of predictions or observations
+
+    Example:
+        >>> target = torch.tensor([1, 10, 1e6])
+        >>> preds = torch.tensor([0.9, 15, 1.2e6])
+        >>> sum_abs_per_error, num_obs = _mean_absolute_percentage_error_update(preds, target)
+        >>> _mean_absolute_percentage_error_compute(sum_abs_per_error, num_obs)
+        tensor(0.2667)
+
+    """
+    return sum_abs_per_error / num_obs
+
+
+def mean_absolute_percentage_error(preds: Tensor, target: Tensor) -> Tensor:
+    """Compute mean absolute percentage error.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+
+    Return:
+        Tensor with MAPE
+
+    Note:
+        The epsilon value is taken from `scikit-learn's implementation of MAPE`_.
+
+    Example:
+        >>> from torchmetrics.functional.regression import mean_absolute_percentage_error
+        >>> target = torch.tensor([1, 10, 1e6])
+        >>> preds = torch.tensor([0.9, 15, 1.2e6])
+        >>> mean_absolute_percentage_error(preds, target)
+        tensor(0.2667)
+
+    """
+    sum_abs_per_error, num_obs = _mean_absolute_percentage_error_update(preds, target)
+    return _mean_absolute_percentage_error_compute(sum_abs_per_error, num_obs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/minkowski.py

@@ -0,0 +1,84 @@
+# Copyright The PyTorch Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+from torchmetrics.utilities.exceptions import TorchMetricsUserError
+
+
+def _minkowski_distance_update(preds: Tensor, targets: Tensor, p: float) -> Tensor:
+    """Update and return variables required to compute Minkowski distance.
+
+    Checks for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        targets: Ground truth tensor
+        p: Non-negative number acting as the p to the errors
+
+    """
+    _check_same_shape(preds, targets)
+
+    if not (isinstance(p, (float, int)) and p >= 1):
+        raise TorchMetricsUserError(f"Argument ``p`` must be a float or int greater than 1, but got {p}")
+
+    difference = torch.abs(preds - targets)
+    return torch.sum(torch.pow(difference, p))
+
+
+def _minkowski_distance_compute(distance: Tensor, p: float) -> Tensor:
+    """Compute Minkowski Distance.
+
+    Args:
+        distance: Sum of the p-th powers of errors over all observations
+        p: The non-negative numeric power the errors are to be raised to
+
+    Example:
+        >>> preds = torch.tensor([0., 1, 2, 3])
+        >>> target = torch.tensor([0., 2, 3, 1])
+        >>> distance_p_sum = _minkowski_distance_update(preds, target, 5)
+        >>> _minkowski_distance_compute(distance_p_sum, 5)
+        tensor(2.0244)
+
+    """
+    return torch.pow(distance, 1.0 / p)
+
+
+def minkowski_distance(preds: Tensor, targets: Tensor, p: float) -> Tensor:
+    r"""Compute the `Minkowski distance`_.
+
+    .. math:: d_{\text{Minkowski}} = \\sum_{i}^N (| y_i - \\hat{y_i} |^p)^\frac{1}{p}
+
+    This metric can be seen as generalized version of the standard euclidean distance which corresponds to minkowski
+    distance with p=2.
+
+    Args:
+        preds: estimated labels of type Tensor
+        targets: ground truth labels of type Tensor
+        p: int or float larger than 1, exponent to which the difference between preds and target is to be raised
+
+    Return:
+        Tensor with the Minkowski distance
+
+    Example:
+        >>> from torchmetrics.functional.regression import minkowski_distance
+        >>> x = torch.tensor([1.0, 2.8, 3.5, 4.5])
+        >>> y = torch.tensor([6.1, 2.11, 3.1, 5.6])
+        >>> minkowski_distance(x, y, p=3)
+        tensor(5.1220)
+
+    """
+    minkowski_dist_sum = _minkowski_distance_update(preds, targets, p)
+    return _minkowski_distance_compute(minkowski_dist_sum, p)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/mse.py

@@ -0,0 +1,82 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Union
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _mean_squared_error_update(preds: Tensor, target: Tensor, num_outputs: int) -> tuple[Tensor, int]:
+    """Update and returns variables required to compute Mean Squared Error.
+
+    Check for same shape of input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        num_outputs: Number of outputs in multioutput setting
+
+    """
+    _check_same_shape(preds, target)
+    if num_outputs == 1:
+        preds = preds.view(-1)
+        target = target.view(-1)
+    diff = preds - target
+    sum_squared_error = torch.sum(diff * diff, dim=0)
+    return sum_squared_error, target.shape[0]
+
+
+def _mean_squared_error_compute(sum_squared_error: Tensor, num_obs: Union[int, Tensor], squared: bool = True) -> Tensor:
+    """Compute Mean Squared Error.
+
+    Args:
+        sum_squared_error: Sum of square of errors over all observations
+        num_obs: Number of predictions or observations
+        squared: Returns RMSE value if set to False.
+
+    Example:
+        >>> preds = torch.tensor([0., 1, 2, 3])
+        >>> target = torch.tensor([0., 1, 2, 2])
+        >>> sum_squared_error, num_obs = _mean_squared_error_update(preds, target, num_outputs=1)
+        >>> _mean_squared_error_compute(sum_squared_error, num_obs)
+        tensor(0.2500)
+
+    """
+    return sum_squared_error / num_obs if squared else torch.sqrt(sum_squared_error / num_obs)
+
+
+def mean_squared_error(preds: Tensor, target: Tensor, squared: bool = True, num_outputs: int = 1) -> Tensor:
+    """Compute mean squared error.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+        squared: returns RMSE value if set to False
+        num_outputs: Number of outputs in multioutput setting
+
+    Return:
+        Tensor with MSE
+
+    Example:
+        >>> from torchmetrics.functional.regression import mean_squared_error
+        >>> x = torch.tensor([0., 1, 2, 3])
+        >>> y = torch.tensor([0., 1, 2, 2])
+        >>> mean_squared_error(x, y)
+        tensor(0.2500)
+
+    """
+    sum_squared_error, num_obs = _mean_squared_error_update(preds, target, num_outputs=num_outputs)
+    return _mean_squared_error_compute(sum_squared_error, num_obs, squared=squared)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/nrmse.py

@@ -0,0 +1,106 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Union
+
+import torch
+from torch import Tensor
+from typing_extensions import Literal
+
+from torchmetrics.functional.regression.mse import _mean_squared_error_update
+
+
+def _normalized_root_mean_squared_error_update(
+    preds: Tensor, target: Tensor, num_outputs: int, normalization: Literal["mean", "range", "std", "l2"] = "mean"
+) -> tuple[Tensor, int, Tensor]:
+    """Updates and returns the sum of squared errors and the number of observations for NRMSE computation.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+        num_outputs: Number of outputs in multioutput setting
+        normalization: type of normalization to be applied. Choose from "mean", "range", "std", "l2"
+
+    """
+    sum_squared_error, num_obs = _mean_squared_error_update(preds, target, num_outputs)
+
+    target = target.view(-1) if num_outputs == 1 else target
+    if normalization == "mean":
+        denom = torch.mean(target, dim=0)
+    elif normalization == "range":
+        denom = torch.max(target, dim=0).values - torch.min(target, dim=0).values
+    elif normalization == "std":
+        denom = torch.std(target, correction=0, dim=0)
+    elif normalization == "l2":
+        denom = torch.norm(target, p=2, dim=0)
+    else:
+        raise ValueError(
+            f"Argument `normalization` should be either 'mean', 'range', 'std' or 'l2' but got {normalization}"
+        )
+    return sum_squared_error, num_obs, denom
+
+
+def _normalized_root_mean_squared_error_compute(
+    sum_squared_error: Tensor, num_obs: Union[int, Tensor], denom: Tensor
+) -> Tensor:
+    """Calculates RMSE and normalizes it."""
+    rmse = torch.sqrt(sum_squared_error / num_obs)
+    return rmse / denom
+
+
+def normalized_root_mean_squared_error(
+    preds: Tensor,
+    target: Tensor,
+    normalization: Literal["mean", "range", "std", "l2"] = "mean",
+    num_outputs: int = 1,
+) -> Tensor:
+    """Calculates the `Normalized Root Mean Squared Error`_ (NRMSE) also know as scatter index.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+        normalization: type of normalization to be applied. Choose from "mean", "range", "std", "l2" which corresponds
+          to normalizing the RMSE by the mean of the target, the range of the target, the standard deviation of the
+          target or the L2 norm of the target.
+        num_outputs: Number of outputs in multioutput setting
+
+    Return:
+        Tensor with the NRMSE score
+
+    Example:
+        >>> import torch
+        >>> from torchmetrics.functional.regression import normalized_root_mean_squared_error
+        >>> preds = torch.tensor([0., 1, 2, 3])
+        >>> target = torch.tensor([0., 1, 2, 2])
+        >>> normalized_root_mean_squared_error(preds, target, normalization="mean")
+        tensor(0.4000)
+        >>> normalized_root_mean_squared_error(preds, target, normalization="range")
+        tensor(0.2500)
+        >>> normalized_root_mean_squared_error(preds, target, normalization="std")
+        tensor(0.6030)
+        >>> normalized_root_mean_squared_error(preds, target, normalization="l2")
+        tensor(0.1667)
+
+    Example (multioutput):
+        >>> import torch
+        >>> from torchmetrics.functional.regression import normalized_root_mean_squared_error
+        >>> preds = torch.tensor([[0., 1], [2, 3], [4, 5], [6, 7]])
+        >>> target = torch.tensor([[0., 1], [3, 3], [4, 5], [8, 9]])
+        >>> normalized_root_mean_squared_error(preds, target, normalization="mean", num_outputs=2)
+        tensor([0.2981, 0.2222])
+
+    """
+    sum_squared_error, num_obs, denom = _normalized_root_mean_squared_error_update(
+        preds, target, num_outputs=num_outputs, normalization=normalization
+    )
+    return _normalized_root_mean_squared_error_compute(sum_squared_error, num_obs, denom)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/pearson.py

@@ -0,0 +1,189 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import math
+
+import torch
+from torch import Tensor
+
+from torchmetrics.functional.regression.utils import _check_data_shape_to_num_outputs
+from torchmetrics.utilities import rank_zero_warn
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _pearson_corrcoef_update(
+    preds: Tensor,
+    target: Tensor,
+    mean_x: Tensor,
+    mean_y: Tensor,
+    max_abs_dev_x: Tensor,
+    max_abs_dev_y: Tensor,
+    var_x: Tensor,
+    var_y: Tensor,
+    corr_xy: Tensor,
+    num_prior: Tensor,
+    num_outputs: int,
+) -> tuple[Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor]:
+    """Update and returns variables required to compute Pearson Correlation Coefficient.
+
+    Check for same shape of input tensors.
+
+    Args:
+        preds: estimated scores
+        target: ground truth scores
+        mean_x: current mean estimate of x tensor
+        mean_y: current mean estimate of y tensor
+        max_abs_dev_x: current maximum absolute value of x tensor
+        max_abs_dev_y: current maximum absolute value of y tensor
+        var_x: current variance estimate of x tensor
+        var_y: current variance estimate of y tensor
+        corr_xy: current covariance estimate between x and y tensor
+        num_prior: current number of observed observations
+        num_outputs: Number of outputs in multioutput setting
+
+    """
+    # Data checking
+    _check_same_shape(preds, target)
+    _check_data_shape_to_num_outputs(preds, target, num_outputs)
+    num_obs = preds.shape[0]
+
+    batch_mean_x = preds.mean(0)
+    batch_mean_y = target.mean(0)
+    delta_x = batch_mean_x - mean_x
+    delta_y = batch_mean_y - mean_y
+    n_total = num_prior + num_obs
+    mx_new = mean_x + delta_x * num_obs / n_total
+    my_new = mean_y + delta_y * num_obs / n_total
+    if num_obs == 1:
+        delta2_x = batch_mean_x - mx_new
+        delta2_y = batch_mean_y - my_new
+        var_x = var_x + delta2_x * delta_x
+        var_y = var_y + delta2_y * delta_y
+        corr_xy = corr_xy + delta_x * delta2_y
+    else:
+        preds_centered = preds - batch_mean_x
+        target_centered = target - batch_mean_y
+
+        batch_var_x = (preds_centered**2).sum(0)
+        batch_var_y = (target_centered**2).sum(0)
+        batch_cov_xy = (preds_centered * target_centered).sum(0)
+
+        correction = num_prior * num_obs / n_total
+        var_x = var_x + batch_var_x + delta_x**2 * correction
+        var_y = var_y + batch_var_y + delta_y**2 * correction
+
+        corr_xy = corr_xy + batch_cov_xy + delta_x * delta_y * correction
+    max_abs_dev_x = torch.maximum(max_abs_dev_x, torch.max((preds - mx_new).abs(), dim=0)[0])
+    max_abs_dev_y = torch.maximum(max_abs_dev_y, torch.max((target - my_new).abs(), dim=0)[0])
+    return mx_new, my_new, max_abs_dev_x, max_abs_dev_y, var_x, var_y, corr_xy, n_total
+
+
+def _pearson_corrcoef_compute(
+    max_abs_dev_x: Tensor,
+    max_abs_dev_y: Tensor,
+    var_x: Tensor,
+    var_y: Tensor,
+    corr_xy: Tensor,
+    nb: Tensor,
+) -> Tensor:
+    """Compute the final pearson correlation based on accumulated statistics.
+
+    Args:
+        max_abs_dev_x: maximum absolute value of x tensor
+        max_abs_dev_y: maximum absolute value of y tensor
+        var_x: variance estimate of x tensor
+        var_y: variance estimate of y tensor
+        corr_xy: covariance estimate between x and y tensor
+        nb: number of observations
+
+    """
+    # prevent overwrite the inputs
+    var_x = var_x / (nb - 1)
+    var_y = var_y / (nb - 1)
+    corr_xy = corr_xy / (nb - 1)
+    # if var_x, var_y is float16 and on cpu, make it bfloat16 as sqrt is not supported for float16
+    # on cpu, remove this after https://github.com/pytorch/pytorch/issues/54774 is fixed
+    if var_x.dtype == torch.float16 and var_x.device == torch.device("cpu"):
+        var_x = var_x.bfloat16()
+        var_y = var_y.bfloat16()
+    var_x = var_x * torch.pow(max_abs_dev_x, -2)
+    var_y = var_y * torch.pow(max_abs_dev_y, -2)
+    corr_xy = corr_xy / (max_abs_dev_x * max_abs_dev_y)
+    bound = math.sqrt(torch.finfo(var_x.dtype).eps)
+    if (
+        (var_x < bound).any()
+        or (var_y < bound).any()
+        or ~torch.isfinite(var_x).any()
+        or ~torch.isfinite(var_y).any()
+        or ~torch.isfinite(corr_xy).any()
+    ):
+        rank_zero_warn(
+            "The variance of predictions or target is close to zero. This can cause instability in Pearson correlation"
+            "coefficient, leading to wrong results. Consider re-scaling the input if possible or computing using a"
+            f"larger dtype (currently using {var_x.dtype}). Setting the correlation coefficient to nan.",
+            UserWarning,
+        )
+    zero_var_mask = (
+        (var_x < bound) | (var_y < bound) | ~torch.isfinite(var_x) | ~torch.isfinite(var_y) | ~torch.isfinite(corr_xy)
+    )
+    corrcoef = torch.full_like(corr_xy, float("nan"), device=corr_xy.device, dtype=corr_xy.dtype)
+    valid_mask = ~zero_var_mask
+    if valid_mask.any():
+        corrcoef[valid_mask] = (
+            (corr_xy[valid_mask] / (var_x[valid_mask] * var_y[valid_mask]).sqrt()).squeeze().to(corrcoef.dtype)
+        )
+        corrcoef = torch.clamp(corrcoef, -1.0, 1.0)
+    return corrcoef.squeeze()
+
+
+def pearson_corrcoef(preds: Tensor, target: Tensor) -> Tensor:
+    """Compute pearson correlation coefficient.
+
+    Args:
+        preds: estimated scores
+        target: ground truth scores
+
+    Example (single output regression):
+        >>> from torchmetrics.functional.regression import pearson_corrcoef
+        >>> target = torch.tensor([3, -0.5, 2, 7])
+        >>> preds = torch.tensor([2.5, 0.0, 2, 8])
+        >>> pearson_corrcoef(preds, target)
+        tensor(0.9849)
+
+    Example (multi output regression):
+        >>> from torchmetrics.functional.regression import pearson_corrcoef
+        >>> target = torch.tensor([[3, -0.5], [2, 7]])
+        >>> preds = torch.tensor([[2.5, 0.0], [2, 8]])
+        >>> pearson_corrcoef(preds, target)
+        tensor([1., 1.])
+
+    """
+    d = preds.shape[1] if preds.ndim == 2 else 1
+    _temp = torch.zeros(d, dtype=preds.dtype, device=preds.device)
+    mean_x, mean_y, var_x = _temp.clone(), _temp.clone(), _temp.clone()
+    var_y, corr_xy, nb = _temp.clone(), _temp.clone(), _temp.clone()
+    max_abs_dev_x, max_abs_dev_y = _temp.clone(), _temp.clone()
+    _, _, max_abs_dev_x, max_abs_dev_y, var_x, var_y, corr_xy, nb = _pearson_corrcoef_update(
+        preds=preds,
+        target=target,
+        mean_x=mean_x,
+        mean_y=mean_y,
+        max_abs_dev_x=max_abs_dev_x,
+        max_abs_dev_y=max_abs_dev_y,
+        var_x=var_x,
+        var_y=var_y,
+        corr_xy=corr_xy,
+        num_prior=nb,
+        num_outputs=1 if preds.ndim == 1 else preds.shape[-1],
+    )
+    return _pearson_corrcoef_compute(max_abs_dev_x, max_abs_dev_y, var_x, var_y, corr_xy, nb)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/r2.py

@@ -0,0 +1,174 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Union
+
+import torch
+from torch import Tensor
+
+from torchmetrics.utilities import rank_zero_warn
+from torchmetrics.utilities.checks import _check_same_shape
+
+
+def _r2_score_update(preds: Tensor, target: Tensor) -> tuple[Tensor, Tensor, Tensor, int]:
+    """Update and returns variables required to compute R2 score.
+
+    Check for same shape and 1D/2D input tensors.
+
+    Args:
+        preds: Predicted tensor
+        target: Ground truth tensor
+
+    """
+    _check_same_shape(preds, target)
+    if preds.ndim > 2:
+        raise ValueError(
+            "Expected both prediction and target to be 1D or 2D tensors,"
+            f" but received tensors with dimension {preds.shape}"
+        )
+
+    sum_obs = torch.sum(target, dim=0)
+    sum_squared_obs = torch.sum(target * target, dim=0)
+    residual = target - preds
+    rss = torch.sum(residual * residual, dim=0)
+    return sum_squared_obs, sum_obs, rss, target.size(0)
+
+
+def _r2_score_compute(
+    sum_squared_obs: Tensor,
+    sum_obs: Tensor,
+    rss: Tensor,
+    num_obs: Union[int, Tensor],
+    adjusted: int = 0,
+    multioutput: str = "uniform_average",
+) -> Tensor:
+    """Compute R2 score.
+
+    Args:
+        sum_squared_obs: Sum of square of all observations
+        sum_obs: Sum of all observations
+        rss: Residual sum of squares
+        num_obs: Number of predictions or observations
+        adjusted: number of independent regressors for calculating adjusted r2 score.
+        multioutput: Defines aggregation in the case of multiple output scores. Can be one of the following strings:
+
+            * `'raw_values'` returns full set of scores
+            * `'uniform_average'` scores are uniformly averaged
+            * `'variance_weighted'` scores are weighted by their individual variances
+
+    Example:
+        >>> target = torch.tensor([[0.5, 1], [-1, 1], [7, -6]])
+        >>> preds = torch.tensor([[0, 2], [-1, 2], [8, -5]])
+        >>> sum_squared_obs, sum_obs, rss, num_obs = _r2_score_update(preds, target)
+        >>> _r2_score_compute(sum_squared_obs, sum_obs, rss, num_obs, multioutput="raw_values")
+        tensor([0.9654, 0.9082])
+
+    """
+    if num_obs < 2:
+        raise ValueError("Needs at least two samples to calculate r2 score.")
+
+    mean_obs = sum_obs / num_obs
+    tss = sum_squared_obs - sum_obs * mean_obs
+
+    # Account for near constant targets
+    cond_rss = ~torch.isclose(rss, torch.zeros_like(rss), atol=1e-4)
+    cond_tss = ~torch.isclose(tss, torch.zeros_like(tss), atol=1e-4)
+    cond = cond_rss & cond_tss
+
+    raw_scores = torch.ones_like(rss)
+    raw_scores[cond] = 1 - (rss[cond] / tss[cond])
+    raw_scores[cond_rss & ~cond_tss] = 0.0
+
+    if multioutput == "raw_values":
+        r2 = raw_scores
+    elif multioutput == "uniform_average":
+        r2 = torch.mean(raw_scores)
+    elif multioutput == "variance_weighted":
+        tss_sum = torch.sum(tss)
+        r2 = torch.sum(tss / tss_sum * raw_scores)
+    else:
+        raise ValueError(
+            "Argument `multioutput` must be either `raw_values`,"
+            f" `uniform_average` or `variance_weighted`. Received {multioutput}."
+        )
+
+    if adjusted < 0 or not isinstance(adjusted, int):
+        raise ValueError("`adjusted` parameter should be an integer larger or equal to 0.")
+
+    if adjusted != 0:
+        if adjusted > num_obs - 1:
+            rank_zero_warn(
+                "More independent regressions than data points in adjusted r2 score. Falls back to standard r2 score.",
+                UserWarning,
+            )
+        elif adjusted == num_obs - 1:
+            rank_zero_warn("Division by zero in adjusted r2 score. Falls back to standard r2 score.", UserWarning)
+        else:
+            return 1 - (1 - r2) * (num_obs - 1) / (num_obs - adjusted - 1)
+    return r2
+
+
+def r2_score(
+    preds: Tensor,
+    target: Tensor,
+    adjusted: int = 0,
+    multioutput: str = "uniform_average",
+) -> Tensor:
+    r"""Compute r2 score also known as `R2 Score_Coefficient Determination`_.
+
+    .. math:: R^2 = 1 - \frac{SS_{res}}{SS_{tot}}
+
+    where :math:`SS_{res}=\sum_i (y_i - f(x_i))^2` is the sum of residual squares, and
+    :math:`SS_{tot}=\sum_i (y_i - \bar{y})^2` is total sum of squares. Can also calculate
+    adjusted r2 score given by
+
+    .. math:: R^2_{adj} = 1 - \frac{(1-R^2)(n-1)}{n-k-1}
+
+    where the parameter :math:`k` (the number of independent regressors) should
+    be provided as the ``adjusted`` argument.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+        adjusted: number of independent regressors for calculating adjusted r2 score.
+        multioutput: Defines aggregation in the case of multiple output scores. Can be one of the following strings:
+
+            * ``'raw_values'`` returns full set of scores
+            * ``'uniform_average'`` scores are uniformly averaged
+            * ``'variance_weighted'`` scores are weighted by their individual variances
+
+    Raises:
+        ValueError:
+            If both ``preds`` and ``targets`` are not ``1D`` or ``2D`` tensors.
+        ValueError:
+            If ``len(preds)`` is less than ``2`` since at least ``2`` samples are needed to calculate r2 score.
+        ValueError:
+            If ``multioutput`` is not one of ``raw_values``, ``uniform_average`` or ``variance_weighted``.
+        ValueError:
+            If ``adjusted`` is not an ``integer`` greater than ``0``.
+
+    Example:
+        >>> from torchmetrics.functional.regression import r2_score
+        >>> target = torch.tensor([3, -0.5, 2, 7])
+        >>> preds = torch.tensor([2.5, 0.0, 2, 8])
+        >>> r2_score(preds, target)
+        tensor(0.9486)
+
+        >>> target = torch.tensor([[0.5, 1], [-1, 1], [7, -6]])
+        >>> preds = torch.tensor([[0, 2], [-1, 2], [8, -5]])
+        >>> r2_score(preds, target, multioutput='raw_values')
+        tensor([0.9654, 0.9082])
+
+    """
+    sum_squared_obs, sum_obs, rss, num_obs = _r2_score_update(preds, target)
+    return _r2_score_compute(sum_squared_obs, sum_obs, rss, num_obs, adjusted, multioutput)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/torchmetrics/functional/regression/rse.py

@@ -0,0 +1,80 @@
+# Copyright The Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Union
+
+import torch
+from torch import Tensor
+
+from torchmetrics.functional.regression.r2 import _r2_score_update
+
+
+def _relative_squared_error_compute(
+    sum_squared_obs: Tensor,
+    sum_obs: Tensor,
+    sum_squared_error: Tensor,
+    num_obs: Union[int, Tensor],
+    squared: bool = True,
+) -> Tensor:
+    """Computes Relative Squared Error.
+
+    Args:
+        sum_squared_obs: Sum of square of all observations
+        sum_obs: Sum of all observations
+        sum_squared_error: Residual sum of squares
+        num_obs: Number of predictions or observations
+        squared: Returns RRSE value if set to False.
+
+    Example:
+        >>> target = torch.tensor([[0.5, 1], [-1, 1], [7, -6]])
+        >>> preds = torch.tensor([[0, 2], [-1, 2], [8, -5]])
+        >>> # RSE uses the same update function as R2 score.
+        >>> sum_squared_obs, sum_obs, rss, num_obs = _r2_score_update(preds, target)
+        >>> _relative_squared_error_compute(sum_squared_obs, sum_obs, rss, num_obs, squared=True)
+        tensor(0.0632)
+
+    """
+    epsilon = torch.finfo(sum_squared_error.dtype).eps
+    rse = sum_squared_error / torch.clamp(sum_squared_obs - sum_obs * sum_obs / num_obs, min=epsilon)
+    if not squared:
+        rse = torch.sqrt(rse)
+    return torch.mean(rse)
+
+
+def relative_squared_error(preds: Tensor, target: Tensor, squared: bool = True) -> Tensor:
+    r"""Computes the relative squared error (RSE).
+
+    .. math:: \text{RSE} = \frac{\sum_i^N(y_i - \hat{y_i})^2}{\sum_i^N(y_i - \overline{y})^2}
+
+    Where :math:`y` is a tensor of target values with mean :math:`\overline{y}`, and
+    :math:`\hat{y}` is a tensor of predictions.
+
+    If `preds` and `targets` are 2D tensors, the RSE is averaged over the second dim.
+
+    Args:
+        preds: estimated labels
+        target: ground truth labels
+        squared: returns RRSE value if set to False
+    Return:
+        Tensor with RSE
+
+    Example:
+        >>> from torchmetrics.functional.regression import relative_squared_error
+        >>> target = torch.tensor([3, -0.5, 2, 7])
+        >>> preds = torch.tensor([2.5, 0.0, 2, 8])
+        >>> relative_squared_error(preds, target)
+        tensor(0.0514)
+
+    """
+    sum_squared_obs, sum_obs, rss, num_obs = _r2_score_update(preds, target)
+    return _relative_squared_error_compute(sum_squared_obs, sum_obs, rss, num_obs, squared=squared)