Method kernelize

src/transformers/modeling_utils.py:4648–4689

Temporarily register hidden kernel wrappers so `kernelize` can discover and replace them.

(self, mode=None)

        self._loss_function = value

    def kernelize(self, mode=None):
        """Temporarily register hidden kernel wrappers so `kernelize` can discover and replace them."""
        if not is_kernels_available():
            raise ValueError(
                "Kernels are not available. To use kernels, please install kernels using `pip install -U kernels`"
            )
        from kernels import Device, Mode, kernelize

        def attach_hidden_kernels(module):
            for name, fn in getattr(module, "_hidden_kernels", {}).items():
                if name not in dict(module.named_children()):
                    if not isinstance(fn, nn.Module):
                        raise ValueError(
                            f"Attempted to register a kernel for {name}, but it was not a `torch.nn.Module`. "
                            "This means the underlying function needs to be decorated with `@use_kernel_func_from_hub`. "
                            "Please submit and issue to the transformers repo: `https://github.com/huggingface/transformers/issues`."
                        )
                    module.register_module(name, fn)

        def detach_hidden_kernels(module):
            for name in getattr(module, "_hidden_kernels", {}):
                # Skip deregistering if it failed to properly register,
                # i.e. `ValueError` will be raised afterwards
                if hasattr(module, name):
                    delattr(module, name)

        try:
            self.apply(attach_hidden_kernels)

            mode = Mode.INFERENCE if not self.training else Mode.TRAINING if mode is None else mode
            if self.kernel_config is not None:
                from kernels import use_kernel_mapping

                inherit_mapping = not self.kernel_config.use_local_kernel
                with use_kernel_mapping(self.kernel_config.kernel_mapping, inherit_mapping=inherit_mapping):
                    kernelize(self, device=Device(type=self.device.type), mode=mode)
            else:
                kernelize(self, device=Device(type=self.device.type), mode=mode)
            self._use_kernels = True

        finally:
            self.apply(detach_hidden_kernels)

    @property
    def use_kernels(self) -> bool: