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

ignite/engine/engine.py

@@ -148,7 +148,7 @@ class Engine(Serializable):
         self.should_interrupt = False
         self.state = State()
         self._state_dict_user_keys: List[str] = []
-        self._allowed_events: List[EventEnum] = []
+        self._allowed_events: List[Union[str, EventEnum]] = []
 
         self._dataloader_iter: Optional[Iterator[Any]] = None
         self._init_iter: Optional[int] = None
@@ -163,9 +163,7 @@ class Engine(Serializable):
         # generator provided by self._internal_run_as_gen
         self._internal_run_generator: Optional[Generator[Any, None, State]] = None
 
-    def register_events(
-        self, *event_names: Union[List[str], List[EventEnum]], event_to_attr: Optional[dict] = None
-    ) -> None:
+    def register_events(self, *event_names: Union[str, EventEnum], event_to_attr: Optional[dict] = None) -> None:
         """Add events that can be fired.
 
         Registering an event will let the user trigger these events at any point.
@@ -450,7 +448,7 @@ class Engine(Serializable):
                 first, others = ((resolved_engine,), args[1:])
             else:
                 # metrics do not provide engine when registered
-                first, others = (tuple(), args)  # type: ignore[assignment]
+                first, others = (tuple(), args)
 
             func(*first, *(event_args + others), **kwargs)
 
@@ -989,9 +987,9 @@ class Engine(Serializable):
     def _internal_run_as_gen(self) -> Generator[Any, None, State]:
         self.should_terminate = self.should_terminate_single_epoch = self.should_interrupt = False
         self._init_timers(self.state)
+        start_time = time.time()
         try:
             try:
-                start_time = time.time()
                 self._fire_event(Events.STARTED)
                 yield from self._maybe_terminate_or_interrupt()
 
@@ -1010,7 +1008,7 @@ class Engine(Serializable):
                     # time is available for handlers but must be updated after fire
                     self.state.times[Events.EPOCH_COMPLETED.name] = epoch_time_taken
 
-                    if self.should_terminate_single_epoch != "skip_epoch_completed":  # type: ignore[comparison-overlap]
+                    if self.should_terminate_single_epoch != "skip_epoch_completed":
                         handlers_start_time = time.time()
                         self._fire_event(Events.EPOCH_COMPLETED)
                         epoch_time_taken += time.time() - handlers_start_time
@@ -1043,7 +1041,7 @@ class Engine(Serializable):
             self.state.times[Events.COMPLETED.name] = time_taken
 
             # do not fire Events.COMPLETED if we terminated the run with flag `skip_completed=True`
-            if self.should_terminate != "skip_completed":  # type: ignore[comparison-overlap]
+            if self.should_terminate != "skip_completed":
                 handlers_start_time = time.time()
                 self._fire_event(Events.COMPLETED)
                 time_taken += time.time() - handlers_start_time
@@ -1189,9 +1187,9 @@ class Engine(Serializable):
         # internal_run without generator for BC
         self.should_terminate = self.should_terminate_single_epoch = self.should_interrupt = False
         self._init_timers(self.state)
+        start_time = time.time()
         try:
             try:
-                start_time = time.time()
                 self._fire_event(Events.STARTED)
                 self._maybe_terminate_legacy()
 
@@ -1210,7 +1208,7 @@ class Engine(Serializable):
                     # time is available for handlers but must be updated after fire
                     self.state.times[Events.EPOCH_COMPLETED.name] = epoch_time_taken
 
-                    if self.should_terminate_single_epoch != "skip_epoch_completed":  # type: ignore[comparison-overlap]
+                    if self.should_terminate_single_epoch != "skip_epoch_completed":
                         handlers_start_time = time.time()
                         self._fire_event(Events.EPOCH_COMPLETED)
                         epoch_time_taken += time.time() - handlers_start_time
@@ -1243,7 +1241,7 @@ class Engine(Serializable):
             self.state.times[Events.COMPLETED.name] = time_taken
 
             # do not fire Events.COMPLETED if we terminated the run with flag `skip_completed=True`
-            if self.should_terminate != "skip_completed":  # type: ignore[comparison-overlap]
+            if self.should_terminate != "skip_completed":
                 handlers_start_time = time.time()
                 self._fire_event(Events.COMPLETED)
                 time_taken += time.time() - handlers_start_time

ignite/engine/events.py

@@ -91,7 +91,7 @@ class CallableEventWithFilter:
             raise ValueError("Argument every should be integer and greater than zero")
 
         if once is not None:
-            c1 = isinstance(once, numbers.Integral) and once > 0
+            c1 = isinstance(once, int) and once > 0
             c2 = isinstance(once, Sequence) and len(once) > 0 and all(isinstance(e, int) and e > 0 for e in once)
             if not (c1 or c2):
                 raise ValueError(
@@ -240,6 +240,7 @@ class EventEnum(CallableEventWithFilter, Enum):
     def __new__(cls, value: str) -> "EventEnum":
         obj = CallableEventWithFilter.__new__(cls)
         obj._value_ = value
+        # pyrefly: ignore [bad-return]
         return obj
 
 

ignite/handlers/__init__.py

@@ -6,6 +6,7 @@ from ignite.handlers.checkpoint import Checkpoint, DiskSaver, ModelCheckpoint
 from ignite.handlers.clearml_logger import ClearMLLogger
 from ignite.handlers.early_stopping import EarlyStopping
 from ignite.handlers.ema_handler import EMAHandler
+from ignite.handlers.fbresearch_logger import FBResearchLogger
 from ignite.handlers.lr_finder import FastaiLRFinder
 from ignite.handlers.mlflow_logger import MLflowLogger
 from ignite.handlers.neptune_logger import NeptuneLogger
@@ -64,6 +65,7 @@ __all__ = [
     "CyclicalScheduler",
     "create_lr_scheduler_with_warmup",
     "FastaiLRFinder",
+    "FBResearchLogger",
     "EMAHandler",
     "BasicTimeProfiler",
     "HandlersTimeProfiler",

ignite/handlers/checkpoint.py

@@ -315,7 +315,7 @@ class Checkpoint(Serializable):
     """
 
     SAVED_CHECKPOINT = CheckpointEvents.SAVED_CHECKPOINT
-    Item = NamedTuple("Item", [("priority", int), ("filename", str)])
+    Item = NamedTuple("Item", [("priority", Union[int, float]), ("filename", str)])
     _state_dict_all_req_keys = ("_saved",)
 
     def __init__(
@@ -323,7 +323,7 @@ class Checkpoint(Serializable):
         to_save: Mapping,
         save_handler: Union[str, Path, Callable, BaseSaveHandler],
         filename_prefix: str = "",
-        score_function: Optional[Callable] = None,
+        score_function: Optional[Callable[[Engine], Union[int, float]]] = None,
         score_name: Optional[str] = None,
         n_saved: Union[int, None] = 1,
         global_step_transform: Optional[Callable] = None,

ignite/handlers/clearml_logger.py

@@ -862,7 +862,7 @@ class ClearMLSaver(DiskSaver):
         except ImportError:
             try:
                 # Backwards-compatibility for legacy Trains SDK
-                from trains import Task  # type: ignore[no-redef]
+                from trains import Task
             except ImportError:
                 raise ModuleNotFoundError(
                     "This contrib module requires clearml to be installed. "
@@ -937,7 +937,7 @@ class ClearMLSaver(DiskSaver):
         except ImportError:
             try:
                 # Backwards-compatibility for legacy Trains SDK
-                from trains.binding.frameworks import WeightsFileHandler  # type: ignore[no-redef]
+                from trains.binding.frameworks import WeightsFileHandler
             except ImportError:
                 raise ModuleNotFoundError(
                     "This contrib module requires clearml to be installed. "

ignite/handlers/fbresearch_logger.py

@@ -7,7 +7,7 @@ import torch
 
 from ignite import utils
 from ignite.engine import Engine, Events
-from ignite.handlers import Timer
+from ignite.handlers.timing import Timer
 
 MB = 1024.0 * 1024.0
 
@@ -154,7 +154,7 @@ class FBResearchLogger:
         if torch.cuda.is_available():
             cuda_max_mem = f"GPU Max Mem: {torch.cuda.max_memory_allocated() / MB:.0f} MB"
 
-        current_iter = engine.state.iteration % (engine.state.epoch_length + 1)
+        current_iter = ((engine.state.iteration - 1) % engine.state.epoch_length) + 1
         iter_avg_time = self.iter_timer.value()
 
         eta_seconds = iter_avg_time * (engine.state.epoch_length - current_iter)

ignite/handlers/lr_finder.py

@@ -98,15 +98,18 @@ class FastaiLRFinder:
         self._best_loss = None
         self._diverge_flag = False
 
+        assert trainer.state.epoch_length is not None
+        assert trainer.state.max_epochs is not None
+
         # attach LRScheduler to trainer.
         if num_iter is None:
             num_iter = trainer.state.epoch_length * trainer.state.max_epochs
         else:
-            max_iter = trainer.state.epoch_length * trainer.state.max_epochs  # type: ignore[operator]
+            max_iter = trainer.state.epoch_length * trainer.state.max_epochs
             if max_iter < num_iter:
                 max_iter = num_iter
                 trainer.state.max_iters = num_iter
-                trainer.state.max_epochs = ceil(num_iter / trainer.state.epoch_length)  # type: ignore[operator]
+                trainer.state.max_epochs = ceil(num_iter / trainer.state.epoch_length)
 
         if not trainer.has_event_handler(self._reached_num_iterations):
             trainer.add_event_handler(Events.ITERATION_COMPLETED, self._reached_num_iterations, num_iter)
@@ -178,17 +181,14 @@ class FastaiLRFinder:
         loss = idist.all_reduce(loss)
         lr = self._lr_schedule.get_param()
         self._history["lr"].append(lr)
-        if trainer.state.iteration == 1:
-            self._best_loss = loss  # type: ignore[assignment]
-        else:
-            if smooth_f > 0:
-                loss = smooth_f * loss + (1 - smooth_f) * self._history["loss"][-1]
-            if loss < self._best_loss:
-                self._best_loss = loss
+        if trainer.state.iteration != 1 and smooth_f > 0:
+            loss = smooth_f * loss + (1 - smooth_f) * self._history["loss"][-1]
+        if self._best_loss is None or loss < self._best_loss:
+            self._best_loss = loss
         self._history["loss"].append(loss)
 
         # Check if the loss has diverged; if it has, stop the trainer
-        if self._history["loss"][-1] > diverge_th * self._best_loss:  # type: ignore[operator]
+        if self._history["loss"][-1] > diverge_th * self._best_loss:
             self._diverge_flag = True
             self.logger.info("Stopping early, the loss has diverged")
             trainer.terminate()

ignite/handlers/neptune_logger.py

@@ -698,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/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/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

@@ -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

ignite/handlers/visdom_logger.py

@@ -1,7 +1,7 @@
 """Visdom logger and its helper handlers."""
 
 import os
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
 
 import torch
 import torch.nn as nn
@@ -165,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.

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
 
@@ -172,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
@@ -284,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):
@@ -298,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):
@@ -309,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
@@ -346,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):
@@ -358,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/metric.py

@@ -369,6 +369,7 @@ class Metric(Serializable, metaclass=ABCMeta):
         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/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.

ignite/metrics/roc_auc.py

@@ -210,4 +210,5 @@ class RocCurve(EpochMetric):
             tpr = idist.broadcast(tpr, src=0, safe_mode=True)
             thresholds = idist.broadcast(thresholds, src=0, safe_mode=True)
 
+        # pyrefly: ignore [bad-return]
         return fpr, tpr, thresholds

ignite/metrics/ssim.py

@@ -161,11 +161,15 @@ class SSIM(Metric):
             kernel_y = self._gaussian(kernel_size[1], sigma[1])
             if ndims == 3:
                 kernel_z = self._gaussian(kernel_size[2], sigma[2])
+            else:
+                kernel_z = None
         else:
             kernel_x = self._uniform(kernel_size[0])
             kernel_y = self._uniform(kernel_size[1])
             if ndims == 3:
                 kernel_z = self._uniform(kernel_size[2])
+            else:
+                kernel_z = None
 
         result = (
             torch.einsum("i,j->ij", kernel_x, kernel_y)

ignite/metrics/vision/object_detection_average_precision_recall.py

@@ -160,6 +160,9 @@ class ObjectDetectionAvgPrecisionRecall(Metric, _BaseAveragePrecision):
         elif self._area_range == "large":
             min_area = 9216
             max_area = 1e10
+        else:
+            min_area = 0
+            max_area = 1e10
         return torch.logical_and(areas >= min_area, areas <= max_area)
 
     def _check_matching_input(

{pytorch_ignite-0.6.0.dev20250927.dist-info → pytorch_ignite-0.6.0.dev20260101.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytorch-ignite
-Version: 0.6.0.dev20250927
+Version: 0.6.0.dev20260101
 Summary: A lightweight library to help with training neural networks in PyTorch.
 Project-URL: Homepage, https://pytorch-ignite.ai
 Project-URL: Repository, https://github.com/pytorch/ignite
@@ -412,7 +412,7 @@ Few pointers to get you started:
 - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb) [Basic example of LR finder on
   MNIST](https://github.com/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb)
 - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb) [Benchmark mixed precision training on Cifar100:
-  torch.cuda.amp vs nvidia/apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb)
+  torch.amp vs nvidia/apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb)
 - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb) [MNIST training on a single
   TPU](https://github.com/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb)
 - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1E9zJrptnLJ_PKhmaP5Vhb6DTVRvyrKHx) [CIFAR10 Training on multiple TPUs](https://github.com/pytorch/ignite/tree/master/examples/cifar10)