update doc

matching_series.py

@@ -25,7 +25,6 @@ import numpy as np
 # TODO: Add BibTeX citation
 _CITATION = """TBA"""
 
-# TODO: Add description of the module here
 _DESCRIPTION = """\
 Matching Series is a metric for evaluating time-series generation models. It is based on the idea of matching the generated time-series with the original time-series. The metric calculates the Mean Squared Error (distance) between the generated time-series and the original time-series between matched instances. The metric outputs a score greater or equal to 0, where 0 indicates a perfect generation.
 """
@@ -201,31 +200,6 @@ class matching_series(evaluate.Metric):
         pass
 
     def compute(self, *, predictions=None, references=None, **kwargs) -> Optional[dict]:
-        """Compute the evaluation module.
-
-        Usage of positional arguments is not allowed to prevent mistakes.
-
-        Args:
-            predictions (`list/array/tensor`, *optional*):
-                Predictions.
-            references (`list/array/tensor`, *optional*):
-                References.
-            **kwargs (optional):
-                Keyword arguments that will be forwarded to the evaluation module [`~evaluate.EvaluationModule.compute`]
-                method (see details in the docstring).
-
-        Return:
-            `dict` or `None`
-
-            - Dictionary with the results if this evaluation module is run on the main process (`process_id == 0`).
-            - `None` if the evaluation module is not run on the main process (`process_id != 0`).
-
-        ```py
-        >>> import evaluate
-        >>> accuracy =  evaluate.load("accuracy")
-        >>> accuracy.compute(predictions=[0, 1, 1, 0], references=[0, 1, 0, 1])
-        ```
-        """
         all_kwargs = {"predictions": predictions, "references": references, **kwargs}
         if predictions is None and references is None:
             missing_kwargs = {k: None for k in self._feature_names() if k not in all_kwargs}
@@ -259,16 +233,40 @@ class matching_series(evaluate.Metric):
         eps: float = 1e-8,
     ):
         """
-        Compute the scores of the module given the predictions and references
+        Compute the Matching Series metric
+
         Args:
-            predictions: list of generated time series.
-                shape: (num_generation, num_timesteps, num_features)
-            references: list of reference
-                shape: (num_reference, num_timesteps, num_features)
-            batch_size: batch size to use for the computation. If None, the whole dataset is processed at once.
-            cuc_n_calculation: number of Coverage Under Curve calculate times
-            cuc_n_samples: number of samples to use for Coverage Under Curve calculation. If "auto", it uses the number of samples of the predictions.
+            predictions: list of list of list of float or numpy.ndarray: The generated time-series. The shape of the array should be `(num_generation, seq_len, num_features)`.
+            references: list of list of list of float or numpy.ndarray: The original time-series. The shape of the array should be `(num_reference, seq_len, num_features)`.
+            batch_size: int, optional: The batch size for computing the metric. This affects quadratically. Default is None.
+            cuc_n_calculation: int, optional: The number of samples to compute the coverage because sampling exists. Default is 3.
+            cuc_n_samples: list of int, optional: The number of samples to compute the coverage. Default is $[2^i \text{for} i \leq \log_2 n] + [n]$.
+            metric: str, optional: The metric to measure distance between examples. Default is "mse". Available options are "mse", "mae", "rmse".
+            num_processes: int, optional: The number of processes to use for computing the distance. Default is 1.
+            instance_normalization: bool, optional: Whether to normalize the instances along the time axis. Default is False.
+            return_distance: bool, optional: Whether to return the distance matrix. Default is False.
+            return_matching: bool, optional: Whether to return the matching matrix. Default is False.
+            return_each_features: bool, optional: Whether to return the results for each feature. Default is False.
+            return_coverages: bool, optional: Whether to return the coverages. Default is False.
+            return_all: bool, optional: Whether to return all the results. Default is False.
+            dtype: str, optional: The data type used for computation. Default is "float32".
+            eps: float, optional: The epsilon value to avoid division by zero. Default is 1e-8.
         Returns:
+            dict: A dictionary containing the following keys:
+                precision_distance (float): The precision of the distance.
+                recall_distance (float): The recall of the distance.
+                mean_distance (float): The mean of the distance.
+                index_distance (float): The index of the distance.
+                matching_precision (float): The precision of the matching instances.
+                matching_recall (float): The recall of the matching instances.
+                matching_f1 (float): The F1-score of the matching instances.
+                coverages (list of float): The coverages.
+                cuc (float): The coverage under the curve.
+                macro_.* (float): The macro value of the .*.
+                .*_features (list of float): The values computed individually for each feature.
+                distance (numpy.ndarray): The distance matrix.
+                match (numpy.ndarray): The matching matrix.
+                match_inv (numpy.ndarray): The inverse matching matrix.
         """
         if return_all:
             return_distance = True