tdhook.latent.probing.context

Classes

Probe	Base class for protocol classes.
Probing	Linear probing [22] and concept activation vectors [23].

Module Contents

class tdhook.latent.probing.context.Probe

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto(Protocol[T]):
    def meth(self) -> T:
        ...

step(data, **kwargs)

Parameters:

data (Any)

Return type:

Any

class tdhook.latent.probing.context.Probing(key_pattern, probe_factory, relative=True, directions=None, additional_keys=None, classes_to_hook=None, classes_to_skip=None)

Bases: tdhook.contexts.HookingContextFactory

Linear probing [22] and concept activation vectors [23].

Parameters:

• key_pattern (str)

• probe_factory (Callable[[str, str], Probe])

• relative (bool)

• directions (Optional[List[tdhook.hooks.HookDirection]])

• additional_keys (Optional[List[str]])

• classes_to_hook (Optional[List[Type[torch.nn.Module]]])

• classes_to_skip (Optional[List[Type[torch.nn.Module]]])

default_classes_to_hook

default_classes_to_skip

_key_pattern

_hook_manager

_relative = True

_probe_factory

_directions = ['fwd']

_additional_keys = None

property key_pattern: str

Return type:

str

_hook_module(module)

Parameters:

module (tdhook.modules.HookedModule)

Return type:

tdhook.hooks.MultiHookHandle