pytorch-ignite 0.6.0.dev20250310__py3-none-any.whl → 0.6.0.dev20260101__py3-none-any.whl

ignite/handlers/neptune_logger.py

@@ -153,6 +153,13 @@ class NeptuneLogger(BaseLogger):
                     output_transform=lambda loss: {"loss": loss},
                 )
 
+    Note:
+        :class:`~ignite.handlers.neptune_logger.OutputHandler` can handle
+        metrics, state attributes and engine output values of the following format:
+        - scalar values (i.e. int, float)
+        - 0d and 1d pytorch tensors
+        - dicts and list/tuples of previous types
+
     """
 
     def __getattr__(self, attr: Any) -> Any:
@@ -691,6 +698,7 @@ class NeptuneSaver(BaseSaveHandler):
             # hold onto the file stream for uploading.
             # NOTE: This won't load the whole file in memory and upload
             #       the stream in smaller chunks.
+            # pyrefly: ignore [bad-argument-type]
             self._logger[filename].upload(File.from_stream(tmp.file))
 
     @idist.one_rank_only(with_barrier=True)

ignite/handlers/param_scheduler.py

@@ -1122,13 +1122,14 @@ def create_lr_scheduler_with_warmup(
             f"but given {type(lr_scheduler)}"
         )
 
-    if not isinstance(warmup_duration, numbers.Integral):
+    if not isinstance(warmup_duration, int):
         raise TypeError(f"Argument warmup_duration should be integer, but given {warmup_duration}")
 
     if not (warmup_duration > 1):
         raise ValueError(f"Argument warmup_duration should be at least 2 events, but given {warmup_duration}")
 
     warmup_schedulers: List[ParamScheduler] = []
+    milestones_values: List[Tuple[int, float]] = []
 
     for param_group_index, param_group in enumerate(lr_scheduler.optimizer.param_groups):
         if warmup_end_value is None:
@@ -1176,6 +1177,7 @@ def create_lr_scheduler_with_warmup(
         lr_scheduler,
     ]
     durations = [milestones_values[-1][0] + 1]
+    # pyrefly: ignore [bad-argument-type]
     combined_scheduler = ConcatScheduler(schedulers, durations=durations, save_history=save_history)
 
     if output_simulated_values is not None:
@@ -1185,6 +1187,7 @@ def create_lr_scheduler_with_warmup(
                 f"but given {type(output_simulated_values)}."
             )
         num_events = len(output_simulated_values)
+        # pyrefly: ignore [bad-argument-type]
         result = ConcatScheduler.simulate_values(num_events=num_events, schedulers=schedulers, durations=durations)
         for i in range(num_events):
             output_simulated_values[i] = result[i]
@@ -1650,6 +1653,7 @@ class ReduceLROnPlateauScheduler(ParamScheduler):
         self.trainer = trainer
         self.optimizer = optimizer
 
+        min_lr: Union[float, List[float]]
         if "min_lr" in scheduler_kwargs and param_group_index is not None:
             min_lr = scheduler_kwargs["min_lr"]
             if not isinstance(min_lr, float):
@@ -1670,11 +1674,11 @@ class ReduceLROnPlateauScheduler(ParamScheduler):
             _scheduler_kwargs["verbose"] = False
 
         self.scheduler = ReduceLROnPlateau(optimizer, **_scheduler_kwargs)
-        self.scheduler._reduce_lr = self._reduce_lr  # type: ignore[method-assign]
+        self.scheduler._reduce_lr = self._reduce_lr
 
         self._state_attrs += ["metric_name", "scheduler"]
 
-    def __call__(self, engine: Engine, name: Optional[str] = None) -> None:  # type: ignore[override]
+    def __call__(self, engine: Engine, name: Optional[str] = None) -> None:
         if not hasattr(engine.state, "metrics") or self.metric_name not in engine.state.metrics:
             raise ValueError(
                 "Argument engine should have in its 'state', attribute 'metrics' "

ignite/handlers/polyaxon_logger.py

@@ -92,6 +92,13 @@ class PolyaxonLogger(BaseLogger):
             )
             # to manually end a run
             plx_logger.close()
+
+    Note:
+        :class:`~ignite.handlers.polyaxon_logger.OutputHandler` can handle
+        metrics, state attributes and engine output values of the following format:
+        - scalar values (i.e. int, float)
+        - 0d and 1d pytorch tensors
+        - dicts and list/tuples of previous types
     """
 
     def __init__(self, *args: Any, **kwargs: Any):

ignite/handlers/state_param_scheduler.py

@@ -1,7 +1,7 @@
 import numbers
 import warnings
 from bisect import bisect_right
-from typing import Any, List, Sequence, Tuple, Union
+from typing import Any, Callable, List, Sequence, Tuple, Union
 
 from ignite.engine import CallableEventWithFilter, Engine, Events, EventsList
 from ignite.handlers.param_scheduler import BaseParamScheduler
@@ -183,7 +183,13 @@ class LambdaStateScheduler(StateParamScheduler):
 
     """
 
-    def __init__(self, lambda_obj: Any, param_name: str, save_history: bool = False, create_new: bool = False):
+    def __init__(
+        self,
+        lambda_obj: Callable[[int], Union[List[float], float]],
+        param_name: str,
+        save_history: bool = False,
+        create_new: bool = False,
+    ):
         super(LambdaStateScheduler, self).__init__(param_name, save_history, create_new)
 
         if not callable(lambda_obj):

ignite/handlers/tensorboard_logger.py

@@ -145,6 +145,49 @@ class TensorboardLogger(BaseLogger):
                     output_transform=lambda loss: {"loss": loss}
                 )
 
+    Note:
+        :class:`~ignite.handlers.tensorboard_logger.OutputHandler` can handle
+        metrics, state attributes and engine output values of the following format:
+        - scalar values (i.e. int, float)
+        - 0d and 1d pytorch tensors
+        - dicts and list/tuples of previous types
+
+        .. code-block:: python
+
+            # !!! This is not a runnable code !!!
+            evalutator.state.metrics = {
+                "a": 0,
+                "dict_value": {
+                    "a": 111,
+                    "c": {"d": 23, "e": [123, 234]},
+                },
+                "list_value": [12, 13, {"aa": 33, "bb": 44}],
+                "tuple_value": (112, 113, {"aaa": 33, "bbb": 44}),
+            }
+
+            handler = OutputHandler(
+                tag="tag",
+                metric_names="all",
+            )
+
+            handler(evaluator, tb_logger, event_name=Events.EPOCH_COMPLETED)
+            # Behind it would call `tb_logger.writer.add_scalar` on
+            # {
+            #     "tag/a": 0,
+            #     "tag/dict_value/a": 111,
+            #     "tag/dict_value/c/d": 23,
+            #     "tag/dict_value/c/e/0": 123,
+            #     "tag/dict_value/c/e/1": 234,
+            #     "tag/list_value/0": 12,
+            #     "tag/list_value/1": 13,
+            #     "tag/list_value/2/aa": 33,
+            #     "tag/list_value/2/bb": 44,
+            #     "tag/tuple_value/0": 112,
+            #     "tag/tuple_value/1": 113,
+            #     "tag/tuple_value/2/aaa": 33,
+            #     "tag/tuple_value/2/bbb": 44,
+            # }
+
     """
 
     def __init__(self, *args: Any, **kwargs: Any):

ignite/handlers/time_profilers.py

@@ -251,6 +251,7 @@ class BasicTimeProfiler:
         total_eh_time: Union[int, torch.Tensor] = sum(
             [(self.event_handlers_times[e]).sum() for e in Events if e not in self.events_to_ignore]
         )
+        # pyrefly: ignore [no-matching-overload]
         event_handlers_stats = dict(
             [
                 (str(e.name).replace(".", "_"), self._compute_basic_stats(self.event_handlers_times[e]))
@@ -334,6 +335,7 @@ class BasicTimeProfiler:
 
         results_df = pd.DataFrame(
             data=results_dump,
+            # pyrefly: ignore [bad-argument-type]
             columns=[
                 "epoch",
                 "iteration",
@@ -498,14 +500,14 @@ class HandlersTimeProfiler:
 
         self.dataflow_times: List[float] = []
         self.processing_times: List[float] = []
-        self.event_handlers_times: Dict[EventEnum, Dict[str, List[float]]] = {}
+        self.event_handlers_times: Dict[Union[str, EventEnum], Dict[str, List[float]]] = {}
 
     @staticmethod
     def _get_callable_name(handler: Callable) -> str:
         # get name of the callable handler
         return getattr(handler, "__qualname__", handler.__class__.__name__)
 
-    def _create_wrapped_handler(self, handler: Callable, event: EventEnum) -> Callable:
+    def _create_wrapped_handler(self, handler: Callable, event: Union[str, EventEnum]) -> Callable:
         @functools.wraps(handler)
         def _timeit_handler(*args: Any, **kwargs: Any) -> None:
             self._event_handlers_timer.reset()
@@ -530,7 +532,7 @@ class HandlersTimeProfiler:
         t = self._dataflow_timer.value()
         self.dataflow_times.append(t)
 
-    def _reset(self, event_handlers_names: Mapping[EventEnum, List[str]]) -> None:
+    def _reset(self, event_handlers_names: Mapping[Union[str, EventEnum], List[str]]) -> None:
         # reset the variables used for profiling
         self.dataflow_times = []
         self.processing_times = []
@@ -689,6 +691,7 @@ class HandlersTimeProfiler:
 
         results_dump = torch.stack(cols, dim=1).numpy()
 
+        # pyrefly: ignore [bad-argument-type]
         results_df = pd.DataFrame(data=results_dump, columns=headers)
         results_df.to_csv(output_path, index=False)
 

ignite/handlers/tqdm_logger.py

@@ -200,7 +200,7 @@ class ProgressBar(BaseLogger):
             Accepted output value types are numbers, 0d and 1d torch tensors and strings.
 
         """
-        desc = self.tqdm_kwargs.get("desc", None)
+        desc = self.tqdm_kwargs.get("desc", "")
 
         if event_name not in engine._allowed_events:
             raise ValueError(f"Logging event {event_name.name} is not in allowed events for this engine")
@@ -223,8 +223,13 @@ class ProgressBar(BaseLogger):
         super(ProgressBar, self).attach(engine, log_handler, event_name)
         engine.add_event_handler(closing_event_name, self._close)
 
-    def attach_opt_params_handler(  # type: ignore[empty-body]
-        self, engine: Engine, event_name: Union[str, Events], *args: Any, **kwargs: Any
+    def attach_opt_params_handler(
+        self,
+        engine: Engine,
+        event_name: Union[str, Events],
+        *args: Any,
+        **kwargs: Any,
+        # pyrefly: ignore [bad-return]
     ) -> RemovableEventHandle:
         """Intentionally empty"""
         pass
@@ -298,8 +303,7 @@ class _OutputHandler(BaseOutputHandler):
         rendered_metrics = self._setup_output_metrics_state_attrs(engine, log_text=True)
         metrics = OrderedDict()
         for key, value in rendered_metrics.items():
-            key = "_".join(key[1:])  # tqdm has tag as description
-
+            key = "_".join(key[1:])  # skip tag as tqdm has tag as description
             metrics[key] = value
 
         if metrics:

ignite/handlers/visdom_logger.py

@@ -1,7 +1,7 @@
 """Visdom logger and its helper handlers."""
 
 import os
-from typing import Any, Callable, cast, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
 
 import torch
 import torch.nn as nn
@@ -137,6 +137,13 @@ class VisdomLogger(BaseLogger):
                     output_transform=lambda loss: {"loss": loss}
                 )
 
+    Note:
+        :class:`~ignite.handlers.visdom_logger.OutputHandler` can handle
+        metrics, state attributes and engine output values of the following format:
+        - scalar values (i.e. int, float)
+        - 0d and 1d pytorch tensors
+        - dicts and list/tuples of previous types
+
     .. versionchanged:: 0.4.7
         accepts an optional list of `state_attributes`
     """
@@ -158,7 +165,7 @@ class VisdomLogger(BaseLogger):
                 "pip install git+https://github.com/fossasia/visdom.git"
             )
 
-        if num_workers > 0:
+        if num_workers > 0 or TYPE_CHECKING:
             # If visdom is installed, one of its dependencies `tornado`
             # requires also `futures` to be installed.
             # Let's check anyway if we can import it.
@@ -172,7 +179,7 @@ class VisdomLogger(BaseLogger):
                 )
 
         if server is None:
-            server = cast(str, os.environ.get("VISDOM_SERVER_URL", "localhost"))
+            server = os.environ.get("VISDOM_SERVER_URL", "localhost")
 
         if port is None:
             port = int(os.environ.get("VISDOM_PORT", 8097))

ignite/handlers/wandb_logger.py

@@ -1,6 +1,7 @@
 """WandB logger and its helper handlers."""
 
 from typing import Any, Callable, List, Optional, Union
+from warnings import warn
 
 from torch.optim import Optimizer
 
@@ -26,7 +27,7 @@ class WandBLogger(BaseLogger):
     Args:
         args: Positional arguments accepted by `wandb.init`.
         kwargs: Keyword arguments accepted by `wandb.init`.
-            Please see `wandb.init <https://docs.wandb.ai/ref/python/init>`_ for documentation of possible parameters.
+            Please see `wandb.init <https://docs.wandb.ai/ref/python/sdk/functions/init/>`_ for documentation of possible parameters.
 
     Examples:
         .. code-block:: python
@@ -120,6 +121,12 @@ class WandBLogger(BaseLogger):
             )
             evaluator.add_event_handler(Events.COMPLETED, model_checkpoint, {'model': model})
 
+    Note:
+        :class:`~ignite.handlers.wandb_logger.OutputHandler` can handle
+        metrics, state attributes and engine output values of the following format:
+        - scalar values (i.e. int, float)
+        - 0d and 1d pytorch tensors
+        - dicts and list/tuples of previous types
 
     """
 
@@ -166,8 +173,7 @@ class OutputHandler(BaseOutputHandler):
             Default is None, global_step based on attached engine. If provided,
             uses function output as global_step. To setup global step from another engine, please use
             :meth:`~ignite.handlers.wandb_logger.global_step_from_engine`.
-        sync: If set to False, process calls to log in a seperate thread. Default (None) uses whatever
-            the default value of wandb.log.
+        sync: Deprecated, has no function. Argument is kept here for compatibility with existing code.
 
     Examples:
         .. code-block:: python
@@ -278,7 +284,8 @@ class OutputHandler(BaseOutputHandler):
         state_attributes: Optional[List[str]] = None,
     ):
         super().__init__(tag, metric_names, output_transform, global_step_transform, state_attributes)
-        self.sync = sync
+        if sync is not None:
+            warn("The sync argument for the WandBLoggers is no longer used, and may be removed in the future")
 
     def __call__(self, engine: Engine, logger: WandBLogger, event_name: Union[str, Events]) -> None:
         if not isinstance(logger, WandBLogger):
@@ -292,7 +299,7 @@ class OutputHandler(BaseOutputHandler):
             )
 
         metrics = self._setup_output_metrics_state_attrs(engine, log_text=True, key_tuple=False)
-        logger.log(metrics, step=global_step, sync=self.sync)
+        logger.log(metrics, step=global_step)
 
 
 class OptimizerParamsHandler(BaseOptimizerParamsHandler):
@@ -303,8 +310,7 @@ class OptimizerParamsHandler(BaseOptimizerParamsHandler):
             as a sequence.
         param_name: parameter name
         tag: common title for all produced plots. For example, "generator"
-        sync: If set to False, process calls to log in a seperate thread. Default (None) uses whatever
-            the default value of wandb.log.
+        sync: Deprecated, has no function. Argument is kept here for compatibility with existing code.
 
     Examples:
         .. code-block:: python
@@ -340,7 +346,8 @@ class OptimizerParamsHandler(BaseOptimizerParamsHandler):
         self, optimizer: Optimizer, param_name: str = "lr", tag: Optional[str] = None, sync: Optional[bool] = None
     ):
         super(OptimizerParamsHandler, self).__init__(optimizer, param_name, tag)
-        self.sync = sync
+        if sync is not None:
+            warn("The sync argument for the WandBLoggers is no longer used, and may be removed in the future")
 
     def __call__(self, engine: Engine, logger: WandBLogger, event_name: Union[str, Events]) -> None:
         if not isinstance(logger, WandBLogger):
@@ -352,4 +359,4 @@ class OptimizerParamsHandler(BaseOptimizerParamsHandler):
             f"{tag_prefix}{self.param_name}/group_{i}": float(param_group[self.param_name])
             for i, param_group in enumerate(self.optimizer.param_groups)
         }
-        logger.log(params, step=global_step, sync=self.sync)
+        logger.log(params, step=global_step)

ignite/metrics/accuracy.py

@@ -254,6 +254,8 @@ class Accuracy(_BaseClassification):
             y_pred = torch.transpose(y_pred, 1, last_dim - 1).reshape(-1, num_classes)
             y = torch.transpose(y, 1, last_dim - 1).reshape(-1, num_classes)
             correct = torch.all(y == y_pred.type_as(y), dim=-1)
+        else:
+            raise ValueError(f"Unexpected type: {self._type}")
 
         self._num_correct += torch.sum(correct).to(self._device)
         self._num_examples += correct.shape[0]

ignite/metrics/clustering/calinski_harabasz_score.py

@@ -86,7 +86,7 @@ class CalinskiHarabaszScore(_ClusteringMetricBase):
 
         .. testoutput::
 
-            5.733936
+            5.733935832977295
 
     .. versionadded:: 0.5.2
     """

ignite/metrics/clustering/silhouette_score.py

@@ -86,7 +86,7 @@ class SilhouetteScore(_ClusteringMetricBase):
 
         .. testoutput::
 
-            0.12607366
+            0.1260736584663391
 
     .. versionadded:: 0.5.2
     """

ignite/metrics/fbeta.py

@@ -1,4 +1,4 @@
-from typing import Callable, Optional, Union
+from typing import Callable, cast, Optional, Union
 
 import torch
 
@@ -15,7 +15,7 @@ def Fbeta(
     precision: Optional[Precision] = None,
     recall: Optional[Recall] = None,
     output_transform: Optional[Callable] = None,
-    device: Union[str, torch.device] = torch.device("cpu"),
+    device: Optional[Union[str, torch.device]] = None,
 ) -> MetricsLambda:
     r"""Calculates F-beta score.
 
@@ -143,17 +143,26 @@ def Fbeta(
     if not (beta > 0):
         raise ValueError(f"Beta should be a positive integer, but given {beta}")
 
-    if precision is not None and output_transform is not None:
-        raise ValueError("If precision argument is provided, output_transform should be None")
+    if precision is not None:
+        if output_transform is not None:
+            raise ValueError("If precision argument is provided, output_transform should be None")
+        if device is not None:
+            raise ValueError("If precision argument is provided, device should be None")
 
-    if recall is not None and output_transform is not None:
-        raise ValueError("If recall argument is provided, output_transform should be None")
+    if recall is not None:
+        if output_transform is not None:
+            raise ValueError("If recall argument is provided, output_transform should be None")
+        if device is not None:
+            raise ValueError("If recall argument is provided, device should be None")
+
+    if precision is None and recall is None and device is None:
+        device = torch.device("cpu")
 
     if precision is None:
         precision = Precision(
             output_transform=(lambda x: x) if output_transform is None else output_transform,
             average=False,
-            device=device,
+            device=cast(Union[str, torch.device], recall._device if recall else device),
         )
     elif precision._average:
         raise ValueError("Input precision metric should have average=False")
@@ -162,7 +171,7 @@ def Fbeta(
         recall = Recall(
             output_transform=(lambda x: x) if output_transform is None else output_transform,
             average=False,
-            device=device,
+            device=cast(Union[str, torch.device], precision._device if precision else device),
         )
     elif recall._average:
         raise ValueError("Input recall metric should have average=False")

ignite/metrics/gan/fid.py

@@ -31,13 +31,13 @@ def fid_score(
     except ImportError:
         raise ModuleNotFoundError("fid_score requires scipy to be installed.")
 
-    mu1, mu2 = mu1.cpu(), mu2.cpu()
-    sigma1, sigma2 = sigma1.cpu(), sigma2.cpu()
+    mu1, mu2 = mu1.detach().cpu(), mu2.detach().cpu()
+    sigma1, sigma2 = sigma1.detach().cpu(), sigma2.detach().cpu()
 
     diff = mu1 - mu2
 
     # Product might be almost singular
-    covmean, _ = scipy.linalg.sqrtm(sigma1.mm(sigma2), disp=False)
+    covmean, _ = scipy.linalg.sqrtm(sigma1.mm(sigma2).numpy(), disp=False)
     # Numerical error might give slight imaginary component
     if np.iscomplexobj(covmean):
         if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):

ignite/metrics/js_divergence.py

@@ -73,7 +73,7 @@ class JSDivergence(KLDivergence):
 
         .. testoutput::
 
-           0.16266516844431558
+           0.1626...
 
     .. versionchanged:: 0.5.1
         ``skip_unrolling`` argument is added.

ignite/metrics/maximum_mean_discrepancy.py

@@ -78,7 +78,7 @@ class MaximumMeanDiscrepancy(Metric):
 
         .. testoutput::
 
-           1.072697639465332
+           1.0726...
 
     .. versionchanged:: 0.5.1
         ``skip_unrolling`` argument is added.

ignite/metrics/metric.py

@@ -361,12 +361,15 @@ class Metric(Serializable, metaclass=ABCMeta):
         device: Union[str, torch.device] = torch.device("cpu"),
         skip_unrolling: bool = False,
     ):
+        if not callable(output_transform):
+            raise TypeError(f"Argument output_transform should be callable, got {type(output_transform)}")
         self._output_transform = output_transform
 
         # Some metrics have a large performance regression when run on XLA devices, so for now, we disallow it.
         if torch.device(device).type == "xla":
             raise ValueError("Cannot create metric on an XLA device. Use device='cpu' instead.")
 
+        # pyrefly: ignore [read-only]
         self._device = torch.device(device)
         self._skip_unrolling = skip_unrolling
 

ignite/metrics/nlp/bleu.py

@@ -2,6 +2,7 @@ import math
 from typing import Any, Callable, Sequence, Tuple, Union
 
 import torch
+from torch import Tensor
 
 from ignite.exceptions import NotComputableError
 from ignite.metrics.metric import Metric, reinit__is_reduced, sync_all_reduce
@@ -71,11 +72,11 @@ class Bleu(Metric):
 
     More details can be found in `Papineni et al. 2002`__.
 
-    __ https://www.aclweb.org/anthology/P02-1040
+    __ https://aclanthology.org/P02-1040/
 
     In addition, a review of smoothing techniques can be found in `Chen et al. 2014`__
 
-    __ https://aclanthology.org/W14-3346.pdf
+    __ https://aclanthology.org/W14-3346/
 
     - ``update`` must receive output of the form ``(y_pred, y)`` or ``{'y_pred': y_pred, 'y': y}``.
     - `y_pred` (list(list(str))) - a list of hypotheses sentences.
@@ -236,12 +237,12 @@ class Bleu(Metric):
     @reinit__is_reduced
     def reset(self) -> None:
         if self.average == "macro":
-            self._sum_of_bleu = torch.tensor(0.0, dtype=torch.double, device=self._device)
+            self._sum_of_bleu = torch.tensor(0.0, dtype=self._double_dtype, device=self._device)
             self._num_sentences = 0
 
         if self.average == "micro":
-            self.p_numerators = torch.zeros(self.ngrams_order + 1)
-            self.p_denominators = torch.zeros(self.ngrams_order + 1)
+            self.p_numerators = torch.zeros(self.ngrams_order + 1, dtype=self._double_dtype)
+            self.p_denominators = torch.zeros(self.ngrams_order + 1, dtype=self._double_dtype)
             self.hyp_length_sum = 0
             self.ref_length_sum = 0
 
@@ -278,8 +279,9 @@ class Bleu(Metric):
         )
         return bleu_score
 
-    def compute(self) -> None:
+    def compute(self) -> Union[None, Tensor, float]:
         if self.average == "macro":
             return self._compute_macro()
         elif self.average == "micro":
             return self._compute_micro()
+        return None

ignite/metrics/nlp/rouge.py

@@ -1,6 +1,5 @@
 from abc import ABCMeta, abstractmethod
-from collections import namedtuple
-from typing import Any, Callable, List, Mapping, Optional, Sequence, Tuple, Union
+from typing import Any, Callable, List, Mapping, NamedTuple, Optional, Sequence, Tuple, Union
 
 import torch
 
@@ -13,11 +12,15 @@ from ignite.metrics.nlp.utils import lcs, ngrams
 __all__ = ["Rouge", "RougeN", "RougeL"]
 
 
-class Score(namedtuple("Score", ["match", "candidate", "reference"])):
+class Score(NamedTuple):
     r"""
     Computes precision and recall for given matches, candidate and reference lengths.
     """
 
+    match: int
+    candidate: int
+    reference: int
+
     def precision(self) -> float:
         """
         Calculates precision.
@@ -191,7 +194,7 @@ class RougeN(_BaseRouge):
 
     More details can be found in `Lin 2004`__.
 
-    __ https://www.aclweb.org/anthology/W04-1013.pdf
+    __ https://aclanthology.org/W04-1013
 
     - ``update`` must receive output of the form ``(y_pred, y)`` or ``{'y_pred': y_pred, 'y': y}``.
     - `y_pred` (list(list(str))) must be a sequence of tokens.
@@ -265,7 +268,7 @@ class RougeL(_BaseRouge):
 
     More details can be found in `Lin 2004`__.
 
-    __ https://www.aclweb.org/anthology/W04-1013.pdf
+    __ https://aclanthology.org/W04-1013
 
     - ``update`` must receive output of the form ``(y_pred, y)`` or ``{'y_pred': y_pred, 'y': y}``.
     - `y_pred` (list(list(str))) must be a sequence of tokens.
@@ -331,7 +334,7 @@ class Rouge(Metric):
 
     More details can be found in `Lin 2004`__.
 
-    __ https://www.aclweb.org/anthology/W04-1013.pdf
+    __ https://aclanthology.org/W04-1013
 
     - ``update`` must receive output of the form ``(y_pred, y)`` or ``{'y_pred': y_pred, 'y': y}``.
     - `y_pred` (list(list(str))) must be a sequence of tokens.

ignite/metrics/nlp/utils.py

@@ -63,7 +63,7 @@ def modified_precision(references: Sequence[Sequence[Any]], candidate: Any, n: i
 
     More details can be found in `Papineni et al. 2002`__.
 
-    __ https://www.aclweb.org/anthology/P02-1040.pdf
+    __ https://aclanthology.org/P02-1040
 
     Args:
         references: list of references R

ignite/metrics/precision_recall_curve.py

@@ -97,7 +97,7 @@ class PrecisionRecallCurve(EpochMetric):
         if len(self._predictions) < 1 or len(self._targets) < 1:
             raise NotComputableError("PrecisionRecallCurve must have at least one example before it can be computed.")
 
-        if self._result is None:  # type: ignore
+        if self._result is None:
             _prediction_tensor = torch.cat(self._predictions, dim=0)
             _target_tensor = torch.cat(self._targets, dim=0)
 
@@ -110,11 +110,11 @@ class PrecisionRecallCurve(EpochMetric):
             if idist.get_rank() == 0:
                 # Run compute_fn on zero rank only
                 precision, recall, thresholds = cast(Tuple, self.compute_fn(_prediction_tensor, _target_tensor))
-                precision = torch.tensor(precision, device=_prediction_tensor.device)
-                recall = torch.tensor(recall, device=_prediction_tensor.device)
+                precision = torch.tensor(precision, device=_prediction_tensor.device, dtype=self._double_dtype)
+                recall = torch.tensor(recall, device=_prediction_tensor.device, dtype=self._double_dtype)
                 # thresholds can have negative strides, not compatible with torch tensors
                 # https://discuss.pytorch.org/t/negative-strides-in-tensor-error/134287/2
-                thresholds = torch.tensor(thresholds.copy(), device=_prediction_tensor.device)
+                thresholds = torch.tensor(thresholds.copy(), device=_prediction_tensor.device, dtype=self._double_dtype)
             else:
                 precision, recall, thresholds = None, None, None
 
@@ -126,4 +126,4 @@ class PrecisionRecallCurve(EpochMetric):
 
             self._result = (precision, recall, thresholds)  # type: ignore[assignment]
 
-        return cast(Tuple[torch.Tensor, torch.Tensor, torch.Tensor], self._result)  # type: ignore
+        return cast(Tuple[torch.Tensor, torch.Tensor, torch.Tensor], self._result)