Ftpfn

FTPFNSurrogate

FTPFNSurrogate(
    target_path: Path | None = None,
    version: str = "0.0.1",
    device: device | None = None,
)

Wrapper around the IfBO model.

Source code in neps/optimizers/models/ftpfn.py

def __init__(
    self,
    target_path: Path | None = None,
    version: str = "0.0.1",
    device: torch.device | None = None,
):
    if target_path is None:
        # TODO: We also probably want to link this to the actual root directory
        # or some shared directory between runs as relying on the path of the initial
        # python invocation is likely to lead to issues somewhere.
        # TODO: ifbo support for windows has issues with decompression
        # We basically just do the same thing they do but manually
        target_path = _download_workaround_for_ifbo_issue_10(target_path, version)

    key = (str(target_path), version)
    ftpfn = _CACHED_FTPFN_MODEL.get(key)
    if ftpfn is None:
        ftpfn = FTPFN(target_path=target_path, version=version, device=device)
        _CACHED_FTPFN_MODEL[key] = ftpfn

    self.ftpfn = ftpfn
    self.device = self.ftpfn.device

encode_ftpfn

encode_ftpfn(
    trials: Mapping[str, Trial],
    fid: tuple[str, Integer | Float],
    budget_domain: Domain,
    encoder: ConfigEncoder,
    *,
    device: device | None = None,
    dtype: dtype = FTPFN_DTYPE,
    error_value: float = 0.0,
    pending_value: float = nan
) -> tuple[Tensor, Tensor]

Encode the trials into a format that the FTPFN model can understand.

Pending trials

For trials which do not have a loss reported yet, they are considered pending. By default this is torch.nan and we recommend fantasizing these values.

Error values

The FTPFN model requires that all loss values lie in the interval [0, 1]. By default, using the value of error_value=0.0, we encode crashed configurations as having an error value of 0.

PARAMETER	DESCRIPTION
trials	The trials to encode TYPE: Mapping[str, Trial]
encoder	The encoder to use TYPE: ConfigEncoder
space	The search space
budget_domain	The domain to use for the budgets of the FTPFN TYPE: Domain
device	The device to use TYPE: device | None DEFAULT: None
dtype	The dtype to use TYPE: dtype DEFAULT: FTPFN_DTYPE

RETURNS	DESCRIPTION
tuple[Tensor, Tensor]	The encoded trials and their corresponding scores

Source code in neps/optimizers/models/ftpfn.py

def encode_ftpfn(
    trials: Mapping[str, Trial],
    fid: tuple[str, Integer | Float],
    budget_domain: Domain,
    encoder: ConfigEncoder,
    *,
    device: torch.device | None = None,
    dtype: torch.dtype = FTPFN_DTYPE,
    error_value: float = 0.0,
    pending_value: float = torch.nan,
) -> tuple[torch.Tensor, torch.Tensor]:
    """Encode the trials into a format that the FTPFN model can understand.

    !!! warning "Pending trials"

        For trials which do not have a loss reported yet, they are considered pending.
        By default this is torch.nan and we recommend fantasizing these values.

    !!! warning "Error values"

        The FTPFN model requires that all loss values lie in the interval [0, 1].
        By default, using the value of `error_value=0.0`, we encode crashed configurations
        as having an error value of 0.

    Args:
        trials: The trials to encode
        encoder: The encoder to use
        space: The search space
        budget_domain: The domain to use for the budgets of the FTPFN
        device: The device to use
        dtype: The dtype to use

    Returns:
        The encoded trials and their corresponding **scores**
    """
    # Select all trials which have something we can actually use for modelling
    # The absence of a report signifies pending
    selected = dict(trials.items())
    fidelity_name, fidelity = fid

    assert 0 <= error_value <= 1
    train_configs = encoder.encode(
        [t.config for t in selected.values()], device=device, dtype=dtype
    )
    ids = torch.tensor(
        [int(config_id.split("_", maxsplit=1)[0]) for config_id in selected],
        device=device,
        dtype=dtype,
    )
    # PFN uses `0` id for test configurations
    ids = ids + 1

    train_fidelities = torch.tensor(
        [t.config[fidelity_name] for t in selected.values()],
        device=device,
        dtype=dtype,
    )
    train_max_cost_total = budget_domain.cast(
        train_fidelities, frm=fidelity.domain, dtype=dtype
    )

    # TODO: Document that it's on the user to ensure these are already all bounded
    # We could possibly include some bounded transform to assert this.
    minimize_ys = torch.tensor(
        [
            pending_value
            if trial.report is None
            else (
                error_value
                if trial.report.objective_to_minimize is None
                else trial.report.objective_to_minimize
            )
            for trial in trials.values()
        ],
        device=device,
        dtype=dtype,
    )
    if minimize_ys.max() > 1 or minimize_ys.min() < 0:
        raise RuntimeError(
            "ifBO requires that all loss values reported lie in the interval [0, 1]"
            " but recieved loss value outside of that range!"
            f"\n{minimize_ys}"
        )
    maximize_ys = 1 - minimize_ys
    x_train = torch.cat(
        [ids.unsqueeze(1), train_max_cost_total.unsqueeze(1), train_configs], dim=1
    )
    return x_train, maximize_ys