[Feature Request] "Removable" event handlers.

I’m happy to open a PR for this immediately if the feature seems useful.

Ignite’s event interface provides both add and remove operations however the “remove” operation requires a reference to the original event handler. This makes temporary or one-off event handlers somewhat tricky to implement.

Pytorch’s existing hook interface provides a solution to this issue by returning a “RemovableHandle” handle from register_hook, holding a weakref to the target hook to support later removal.

Ignite’s add_event_handler should implement a similar interface, returning a “RemovableEventHandle” rather than None. For example, in an attrs-style syntax:

@attr.s(auto_attribs=True)
class RemovableEventHandle:
    """Removable weak reference to an added event handler."""


    event_name: str
    handler: weakref.ref = attr.ib(converter=_as_weakref)
    engine: weakref.ref = attr.ib(converter=_as_weakref)

    def remove(self):
        """Remove handler from engine."""
        handler = self.handler()
        engine: Engine = self.engine()

        if handler and engine and engine.has_event_handler(handler):
            engine.remove_event_handler(handler, self.event_name)

    def __enter__(self):  # noqa: D
        return self

    def __exit__(self, type, value, tb):  # noqa: D
        self.remove()

Would support features like:

engine = Engine(process_function)

def print_epoch(engine):
    print("Epoch: {}".format(engine.state.epoch))

# Train with a temporary event handler.
with engine.add_event_handler(Events.EPOCH_COMPLETED, print_epoch):
    engine.run(dataloader, 10)

[asford]

Probably, we could integrate it without attrib as a new dependency… What do yout think ?

Absolutely, I’ll open a PR with a vanilla implementation shortly.

[asford]

Yes, there are multiple ways of implementing the equivalent behavior for single-shot handlers. I’ve just found this method to be low-overhead and relatively easy to keep tidy.

As you point out, I’m also using this feature to “reuse” an evaluator engine across multiple datasets with different logging configurations.

I think the context manger support offered by this feature is the key to increased usability.