hpoglue 0.1.0

A lightweight framework for benchmarking HPO algorithms

hpoglue

HPO tool with a modular API that allows for the easy interfacing of a new Optimizer and a new Benchmark

Minimal Example to run hpoglue

from hpoglue.run_glue import run_glue
df = run_glue(
    run_name="hpoglue_ex",
    optimizer = ...,
    benchmark = ...,
    seed = 1,
    budget = 50
)

[!TIP]

• See below for examples of an Optimizer and Benchmark
• Check this example notebook for more
• Check out hposuite for some already implemented Optimizers and Benchmarks for hpoglue

Installation

Create a Virtual Environment using Venv

python -m venv hpoglue_env
source hpoglue_env/bin/activate

Installing from PyPI

pip install hpoglue

[!TIP]

• pip install hpoglue["notebook"] - For usage in a notebook

Installation from source

git clone https://github.com/automl/hpoglue.git
cd hpoglue

pip install -e . # -e for editable install

Example Optimizer Definition

from ConfigSpace import ConfigurationSpace
from hpoglue.config import Config
from hpoglue.optimizer import Optimizer
from hpoglue.problem import Problem
from hpoglue.query import Query


class RandomSearch(Optimizer):
    name = "RandomSearch"
    support = Problem.Support()
    def __init__(self, problem, seed, working_directory, config_space):
        self.config_space = config_space
        self.config_space.seed(seed)
        self.problem = problem
        self._counter = 0

    def ask(self):
        self._counter += 1
        config = Config(
            config_id=str(self._counter),
            values=self.config_space.sample_configuration().get_dictionary(),
        )
        return Query(config=config, fidelity=None)

    def tell(self, result):
        return

Example Benchmark Definition

import numpy as np
from ConfigSpace import ConfigurationSpace, Float
from hpoglue.benchmark import FunctionalBenchmark
from hpoglue.measure import Measure
from hpoglue.result import Result

def ackley_bench():
    ackley_space = ConfigurationSpace()
    for i in range(2):
        ackley_space.add(Float(name=f"x{i}", bounds=[-32.768, 32.768]))
    return FunctionalBenchmark(
        name="ackley",
        config_space=ackley_space,
        metrics={"value": Measure.metric((0.0, np.inf), minimize=True)},
        query=ackley,
    )

def ackley(query):
    x = np.array(query.config.to_tuple())
    n_var=2
    a=20
    b=1/5
    c=2 * np.pi
    part1 = -1. * a * np.exp(-1. * b * np.sqrt((1. / n_var) * np.sum(x * x)))
    part2 = -1. * np.exp((1. / n_var) * np.sum(np.cos(c * x)))
    out = part1 + part2 + a + np.exp(1)
    return Result(
        query=query,
        fidelity=None,
        values={"value": out},
    )