Examples

If you have Unified Planning, up_ac and the respective AC method installed as described, you should be able to run the codes repective to the installed AC method.

Quality tuning Fast-Downward with SMAC

"""Test up AC implementation."""
import up_ac
import sys
import os

from up_ac.Smac_configurator import SmacConfigurator
from up_ac.Smac_interface import SmacInterface

# Get example PPDL files from up_ac
path = '/' + os.path.abspath(up_ac.__file__).strip('/__init__.py')
sys.path.insert(0, sys.path[0].rsplit('up-ac', 1)[0] + '/up-ac')

# You can also provide a list of tuples (instance, domain) if some domains are
# located in different places
instances = [f'{path}/test_problems/visit_precedence/problem.pddl',
             f'{path}/test_problems/counters/problem.pddl',
             f'{path}/test_problems/depot/problem.pddl',
             f'{path}/test_problems/miconic/problem.pddl',
             f'{path}/test_problems/matchcellar/problem.pddl']

engines = ['fast-downward']
metric = 'quality'
timelimit = 30
plantype = 'OneshotPlanner'

# initialize SMAC Algorithm Configuration interface
sgaci = SmacInterface()

# A custom pcs is possible
sgaci.read_engine_pcs(engines, f'{path}/engine_pcs')

engine = engines[0]

# Compute pddl instance features
instance_features = {}
for instance in instances:
    if isinstance(instance, tuple):
        domain = instance[1]
        instance = instance[0]
        instance_features[instance] \
            = sgaci.compute_instance_features(
                domain,
                instance)
    else:
        instance_features[instance] \
            = sgaci.compute_instance_features(
                instance.rsplit('/', 1)[0] + '/domain.pddl',
                instance)

# Make UP print less
up.shortcuts.get_environment().credits_stream = None

if __name__ == '__main__':

    # Initialize algorithm configurator
    SAC = SmacConfigurator()
    SAC.get_instance_features(instance_features)
    SAC.set_training_instance_set(instances)
    SAC.set_test_instance_set(instances)

    SAC.set_scenario(engine, sgaci.engine_param_spaces[engine],
                     sgaci, configuration_time=180, n_trials=30,
                     min_budget=2, max_budget=5, crash_cost=10000,
                     planner_timelimit=timelimit, n_workers=4,
                     instance_features=SAC.instance_features,
                     metric=metric)

    SAC_fb_func = SAC.get_feedback_function(sgaci, engine,
                                            metric, plantype)

    # Run algorithm configuration
    incumbent, _ = SAC.optimize(feedback_function=SAC_fb_func)

    # Check configurations performance
    perf = SAC.evaluate(metric, engine, plantype, SAC.incumbent,
                        sgaci, planner_timelimit=timelimit)

    # Save best configuration found
    SAC.save_config('.', incumbent, sgaci, engine, plantype)

Runtime tuning SymK with OAT

"""Test up AC implementation."""
import sys
import os
import up_ac

from up_ac.OAT_configurator import OATConfigurator
from up_ac.OAT_interface import OATInterface

# Get example PPDL files from up_ac
path = '/' + os.path.abspath(up_ac.__file__).strip('/__init__.py')
sys.path.insert(0, sys.path[0].rsplit('up-ac', 1)[0] + '/up-ac')

# You can also provide a list of tuples (instance, domain) if some domains are
# located in different places
instances = [f'{path}/test_problems/miconic/problem.pddl',
             f'{path}/test_problems/depot/problem.pddl',
             f'{path}/test_problems/safe_road/problem.pddl']

engines = ['symk']
metric = 'runtime'
timelimit = 30
plantype = 'OneshotPlanner'

# Initialize OAT Algorithm Configuration interface
ogaci = OATInterface()

# You can pass multiple planning engines
ogaci.read_engine_pcs(engines, f'{path}/engine_pcs')

engine = engines[0]


if __name__ == '__main__':

    # Initialize algorithm configurator
    OAC = OATConfigurator()
    OAC.set_training_instance_set(instances)
    OAC.set_test_instance_set(instances)

    OAC.set_scenario(engine, ogaci.engine_param_spaces[engine],
                     ogaci, configuration_time=300, n_trials=30,
                     crash_cost=10000, planner_timelimit=timelimit,
                     n_workers=4, instance_features=None, popSize=5,
                     metric=metric, evalLimit=1)

    OAC_fb_func = OAC.get_feedback_function(ogaci, engine,
                                            metric, plantype)
    # Run algorithm configuration
    incumbent, _ = OAC.optimize(feedback_function=OAC_fb_func)

    # Check configurations performance
    perf = OAC.evaluate(metric, engine, plantype, OAC.incumbent,
                        ogaci)

    # Save best configuration found
    OAC.save_config('.', OAC.incumbent, ogaci, engine, plantype)

Anytime tuning ENHSP with Irace

"""Test up AC implementation."""
import up_ac
import os
import sys

from up_ac.Irace_configurator import IraceConfigurator
from up_ac.Irace_interface import IraceInterface

# Get example PPDL files from up_ac
path = '/' + os.path.abspath(up_ac.__file__).strip('/__init__.py')
sys.path.insert(0, sys.path[0].rsplit('up-ac', 1)[0] + '/up-ac')

# You can also provide a list of tuples (instance, domain) if some domains are
# located in different places
instances = [f'{path}/test_problems/depot/problem.pddl',
             f'{path}/test_problems/counters/problem.pddl',
             f'{path}/test_problems/citycar/problem.pddl',
             f'{path}/test_problems/sailing/problem.pddl']

engines = ['enhsp-any']
metric = 'quality'
timelimit = 30
plantype = 'AnytimePlanner'

# Initialize Irace Algorithm Configuration interface
igaci = IraceInterface()

# A custom pcs is possible
igaci.read_engine_pcs(engines, f'{path}/engine_pcs')

engine = engines[0]

# Make UP print less
up.shortcuts.get_environment().credits_stream = None

if __name__ == '__main__':

    # Initialize algorithm configurator
    IAC = IraceConfigurator()
    IAC.set_training_instance_set(instances)
    IAC.set_test_instance_set(instances)

    IAC.set_scenario(engine, igaci.engine_param_spaces[engine],
                     igaci, configuration_time=650, n_trials=5,
                     crash_cost=10000, min_budget=2,
                     planner_timelimit=timelimit, n_workers=4,
                     instance_features=None)

    IAC_fb_func = IAC.get_feedback_function(igaci, engine,
                                            metric, plantype)

    # Run algorithm configuration
    incumbent, _ = IAC.optimize(feedback_function=IAC_fb_func)

    # Check configurations performance
    perf = IAC.evaluate(metric, engine, plantype, IAC.incumbent,
                        igaci, planner_timelimit=timelimit)

    # Save best configuration found
    IAC.save_config('.', IAC.incumbent, igaci, engine, plantype)

Anytime tuning LPG with Selector

"""Test up AC implementation."""
import up_ac
import os
import sys

from up_ac.Selector_configurator import SelectorConfigurator
from up_ac.Selector_interface import SelectorInterface

# Get example PPDL files from up_ac
path = '/' + os.path.abspath(up_ac.__file__).strip('/__init__.py'
sys.path.insert(0, sys.path[0].rsplit('up-ac', 1)[0] + '/up-ac')

# You can also provide a list of tuples (instance, domain) if some domains are
# located in different places
train_instances = [f'{path}/test_problems/visit_precedence/problem.pddl',
                   f'{path}/test_problems/counters/problem.pddl',
                   f'{path}/test_problems/depot/problem.pddl']

# Mock test instance set for this example
test_instances = train_instances

engines = ['lpg-anytime']
metric = 'quality'
timelimit = 30
plantype = 'AnytimePlanner'

# Initialize Selector Algorithm Configuration interface
selgaci = SelectorInterface()

# You can pass multiple planning engines
selgaci.read_engine_pcs(engines, f'{path}/engine_pcs')

engine = engines[0]

# Compute pddl instance features
instance_features = {}
for instance in train_instances:
    if isinstance(instance, tuple):
        domain = instance[1]
        instance = instance[0]
        instance_features[instance] \
            = selgaci.compute_instance_features(
                domain,
                instance)
    else:
        instance_features[instance] \
            = selgaci.compute_instance_features(
                instance.rsplit('/', 1)[0] + '/domain.pddl',
                instance)

# Make UP print less
up.shortcuts.get_environment().credits_stream = None

if __name__ == '__main__':

    # Initialize algorithm configurator
    SelAC = SelectorConfigurator()
    SelAC.get_instance_features(instance_features)
    SelAC.set_training_instance_set(train_instances)
    SelAC.set_test_instance_set(test_instances)

    SelAC.set_scenario(engine, selgaci.engine_param_spaces[engine],
                       selgaci, configuration_time=180, tourn_size=2,
                       min_budget=2, max_budget=3, crash_cost=10000,
                       planner_timelimit=timelimit, n_workers=4,
                       instance_features=SelAC.instance_features,
                       output_dir='enhsp_selector', metric=metric)

    SelAC_fb_func = SelAC.get_feedback_function(selgaci, engine,
                                                metric, plantype)

    # Test feedback function
    default_config = \
        selgaci.engine_param_spaces[engine].get_default_configuration()

    # Run algorithm configuration
    incumbent, _ = SelAC.optimize(feedback_function=SelAC_fb_func)

    # Sheck configurations performance on test set
    perf = SelAC.evaluate(metric, engine, plantype, SelAC.incumbent,
                          selgaci, planner_timelimit=timelimit)

    # Save best configuration found
    SelAC.save_config('.', SelAC.incumbent, selgaci, engine, plantype)