Initial fixes with weak references

Author: goanpeca

ignite/engine/engine.py

@@ -328,7 +328,8 @@ def execute_something():
 
         try:
             _check_signature(handler, "handler", self, *(event_args + args), **kwargs)
-            self._event_handlers[event_name].append((handler, (self,) + args, kwargs))
+            # Use weak reference to break circular reference
+            self._event_handlers[event_name].append((handler, (weakref.ref(self),) + args, kwargs))
         except ValueError:
             _check_signature(handler, "handler", *(event_args + args), **kwargs)
             self._event_handlers[event_name].append((handler, args, kwargs))
@@ -432,7 +433,15 @@ def _fire_event(self, event_name: Any, *event_args: Any, **event_kwargs: Any) ->
         self.last_event_name = event_name
         for func, args, kwargs in self._event_handlers[event_name]:
             kwargs.update(event_kwargs)
-            first, others = ((args[0],), args[1:]) if (args and args[0] == self) else ((), args)
+            # Resolve weak references if present
+            if args and isinstance(args[0], weakref.ref):
+                resolved_engine = args[0]()
+                if resolved_engine is None:
+                    # Engine was garbage collected, skip this handler
+                    continue
+                first, others = ((resolved_engine,), args[1:])
+            else:
+                first, others = ((args[0],), args[1:]) if (args and args[0] == self) else (tuple(), args)
             func(*first, *(event_args + others), **kwargs)
 
     def fire_event(self, event_name: Any) -> None:

ignite/handlers/base_logger.py

@@ -3,6 +3,7 @@
 import collections.abc as collections
 import numbers
 import warnings
+import weakref
 from abc import ABCMeta, abstractmethod
 from collections import OrderedDict
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
@@ -261,18 +262,34 @@ def attach(
             :class:`~ignite.engine.events.RemovableEventHandle`, which can be used to remove the handler.
         """
         if isinstance(event_name, EventsList):
+            # Use weak reference to break circular reference: engine -> _event_handlers -> BaseLogger
+            weak_self = weakref.ref(self)
+
+            def weak_log_handler(engine, event_name):
+                logger_obj = weak_self()
+                if logger_obj is not None:
+                    log_handler(engine, logger_obj, event_name)
+
             for name in event_name:
                 if name not in State.event_to_attr:
                     raise RuntimeError(f"Unknown event name '{name}'")
-                engine.add_event_handler(name, log_handler, self, name)
+                engine.add_event_handler(name, weak_log_handler, name)
 
             return RemovableEventHandle(event_name, log_handler, engine)
 
         else:
             if event_name not in State.event_to_attr:
                 raise RuntimeError(f"Unknown event name '{event_name}'")
 
-            return engine.add_event_handler(event_name, log_handler, self, event_name, *args, **kwargs)
+            # Use weak reference to break circular reference: engine -> _event_handlers -> BaseLogger
+            weak_self = weakref.ref(self)
+
+            def weak_log_handler(engine):
+                logger_obj = weak_self()
+                if logger_obj is not None:
+                    log_handler(engine, logger_obj, event_name, *args, **kwargs)
+
+            return engine.add_event_handler(event_name, weak_log_handler)
 
     def attach_output_handler(self, engine: Engine, event_name: Any, *args: Any, **kwargs: Any) -> RemovableEventHandle:
         """Shortcut method to attach `OutputHandler` to the logger.

ignite/handlers/tqdm_logger.py

@@ -2,6 +2,7 @@
 """TQDM logger."""
 from collections import OrderedDict
 from typing import Any, Callable, List, Optional, Union
+import weakref
 
 from ignite.engine import Engine, Events
 from ignite.engine.events import CallableEventWithFilter, RemovableEventHandle
@@ -221,7 +222,15 @@ def attach(  # type: ignore[override]
         )
 
         super(ProgressBar, self).attach(engine, log_handler, event_name)
-        engine.add_event_handler(closing_event_name, self._close)
+        # Use weak reference to break circular reference: engine -> _event_handlers -> ProgressBar
+        weak_self = weakref.ref(self)
+
+        def weak_close(engine):
+            pbar_obj = weak_self()
+            if pbar_obj is not None:
+                pbar_obj._close(engine)
+
+        engine.add_event_handler(closing_event_name, weak_close)
 
     def attach_opt_params_handler(  # type: ignore[empty-body]
         self, engine: Engine, event_name: Union[str, Events], *args: Any, **kwargs: Any

ignite/metrics/metric.py

@@ -4,6 +4,7 @@
 from functools import wraps
 from numbers import Number
 from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+import weakref
 
 import torch
 
@@ -560,11 +561,31 @@ def attach(self, engine: Engine, name: str, usage: Union[str, MetricUsage] = Epo
                 assert metric.is_attached(engine, usage=BatchWise.usage_name)
         """
         usage = self._check_usage(usage)
-        if not engine.has_event_handler(self.started, usage.STARTED):
-            engine.add_event_handler(usage.STARTED, self.started)
-        if not engine.has_event_handler(self.iteration_completed, usage.ITERATION_COMPLETED):
-            engine.add_event_handler(usage.ITERATION_COMPLETED, self.iteration_completed)
-        engine.add_event_handler(usage.COMPLETED, self.completed, name)
+
+        # Use weak reference to break circular reference: engine -> _event_handlers -> Metric
+        weak_self = weakref.ref(self)
+
+        def weak_started(engine: Engine) -> None:
+            metric_obj = weak_self()
+            if metric_obj is not None:
+                metric_obj.started(engine)
+
+        def weak_iteration_completed(engine: Engine) -> None:
+            metric_obj = weak_self()
+            if metric_obj is not None:
+                metric_obj.iteration_completed(engine)
+
+        def weak_completed(engine: Engine, name: str) -> None:
+            metric_obj = weak_self()
+            if metric_obj is not None:
+                metric_obj.completed(engine, name)
+
+        # Skip has_event_handler check since we're using different handler functions
+        # Note: This means handlers may be added multiple times, but that's generally safe
+        # for metrics as they are typically attached once per metric
+        engine.add_event_handler(usage.STARTED, weak_started)
+        engine.add_event_handler(usage.ITERATION_COMPLETED, weak_iteration_completed)
+        engine.add_event_handler(usage.COMPLETED, weak_completed, name)
 
     def detach(self, engine: Engine, usage: Union[str, MetricUsage] = EpochWise()) -> None:
         """