init

README.md

@@ -1,15 +1,50 @@
 ---
-title: Alignment And Uniformity
-emoji: 😻
-colorFrom: green
-colorTo: red
+title: Alignment and Uniformity
+datasets:
+-  
+tags:
+- evaluate
+- metric
+description: "TODO: add a description here"
 sdk: gradio
-sdk_version: 5.3.0
+sdk_version: 3.19.1
 app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: Metrics for Alignment and Uniformity on the Hypersphere. 
 ---
-test
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Metric Card for Alignment and Uniformity
+
+***Module Card Instructions:*** *Fill out the following subsections. Feel free to take a look at existing metric cards if you'd like examples.*
+
+## Metric Description
+*Give a brief overview of this metric, including what task(s) it is usually used for, if any.*
+
+## How to Use
+*Give general statement of how to use the metric*
+
+*Provide simplest possible example for using the metric*
+
+### Inputs
+*List all input arguments in the format below*
+- **input_field** *(type): Definition of input, with explanation if necessary. State any default value(s).*
+
+### Output Values
+
+*Explain what this metric outputs and provide an example of what the metric output looks like. Modules should return a dictionary with one or multiple key-value pairs, e.g. {"bleu" : 6.02}*
+
+*State the range of possible values that the metric's output can take, as well as what in that range is considered good. For example: "This metric can take on any value between 0 and 100, inclusive. Higher scores are better."*
+
+#### Values from Popular Papers
+*Give examples, preferrably with links to leaderboards or publications, to papers that have reported this metric, along with the values they have reported.*
+
+### Examples
+*Give code examples of the metric being used. Try to include examples that clear up any potential ambiguity left from the metric description above. If possible, provide a range of examples that show both typical and atypical results, as well as examples where a variety of input parameters are passed.*
+
+## Limitations and Bias
+*Note any known limitations or biases that the metric has, with links and references if possible.*
+
+## Citation
+*Cite the source where this metric was introduced.*
+
+## Further References
+*Add any useful further references.*

alignment_and_uniformity.py

@@ -0,0 +1,90 @@
+import datasets
+import evaluate
+from typing import List
+import torch
+
+
+_DESCRIPTION = """
+Quantifying encoder feature distribution properties, Alignment and Uniformity on the Hypersphere.
+(https://github.com/ssnl/align_uniform)
+"""
+
+_KWARGS_DESCRIPTION = """
+Args:
+    xs (`list` of a list of `int`): a group of embeddings
+    ys (`list` of `int`): the other group of embeddings paired with the ys
+    
+Returns:
+    "align_loss": float(align_loss_val),
+    "x_unif_loss": float(x_unif_loss_v),
+    "y_unif_loss": float(y_unif_loss_v),
+    "unif_loss": float(unif_loss)
+            
+Examples:
+
+    Example 1-A simple example
+        >>> metrics = evaluate.load("ahnyeonchan/Alignment-and-Uniformity")
+        >>> results = metrics.compute(xs=[[1.0, 1.0], [0.0, 1.0]], ys=[[1.0, 1.0], [0.0, 1.0]])
+        >>> print(results)
+        {'align_loss': 0.0, 'x_unif_loss': -2.0, 'y_unif_loss': -2.0, 'unif_loss': -2.0}
+"""
+
+_CITATION = """"""
+
+
+def align_loss(x, y, alpha=2):
+    return (x - y).norm(p=2, dim=1).pow(alpha).mean()
+
+
+def uniform_loss(x, t=2):
+    return torch.pdist(x, p=2).pow(2).mul(-t).exp().mean().log()
+
+
+@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class AlignUniform(evaluate.Metric):
+    def __init__(self, align_alpha: float = 2.0, unif_t: float = 2.0, *args, **kwargs):
+        super(AlignUniform, self).__init__(*args, **kwargs)
+        self.align_alpha = align_alpha
+        self.unif_t = unif_t
+        
+    def _info(self):
+        return evaluate.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "xs": datasets.Sequence(datasets.Value("float32")),
+                    "ys": datasets.Sequence(datasets.Value("float32")),
+                }
+            ),
+            reference_urls=[],
+        )
+
+    def _compute(self, xs: List[List], ys: List[List]):
+        
+        if isinstance(xs, torch.Tensor):
+            xs = torch.Tensor(xs)
+        elif isinstance(ys, list):
+            xs = torch.Tensor(xs)
+        else:
+            raise NotImplementedError()
+        
+        if isinstance(ys, torch.Tensor):
+            ys = torch.Tensor(ys)
+        elif isinstance(ys, list):
+            ys = torch.Tensor(ys)
+        else:
+            raise NotImplementedError()
+        
+        align_loss_val = align_loss(xs, ys, self.align_alpha)
+        x_unif_loss_v = uniform_loss(xs, t=self.unif_t)
+        y_unif_loss_v = uniform_loss(ys, t=self.unif_t)
+        unif_loss = (x_unif_loss_v + y_unif_loss_v) / 2
+                
+        return {
+            "align_loss": float(align_loss_val),
+            "x_unif_loss": float(x_unif_loss_v),
+            "y_unif_loss": float(y_unif_loss_v),
+            "unif_loss": float(unif_loss)
+        }

app.py

@@ -0,0 +1,6 @@
+import evaluate
+from evaluate.utils import launch_gradio_widget
+
+
+module = evaluate.load("ahnyeonchan/Alignment-and-Uniformity")
+launch_gradio_widget(module)

tests.py

@@ -0,0 +1,8 @@
+test_cases = [
+    {
+        "xs": [[1.0, 1.0], [0.0, 1.0]],
+        "ys": [[1.0, 1.0], [0.0, 1.0]],
+        "result": {'align_loss': 0.0, 'x_unif_loss': -2.0, 'y_unif_loss': -2.0, 'unif_loss': -2.0}
+    }
+        
+]