amlgym.util package

Submodules

amlgym.util.SimpleDomainReader module

class amlgym.util.SimpleDomainReader.Operator(operator_name, parameters, precs_pos, precs_neg, eff_pos, eff_neg)

Bases: object

class amlgym.util.SimpleDomainReader.SimpleDomainReader(input_file=None)

Bases: object

clean_pddl_domain_file(f_name)

empty()

get_op_relevant_predicates(operator)

init_prec_eff()

read(f_name)

read_object_types_hierarchy(f_name)

read_operators(f_name)

read_predicates(f_name)

write(f_name)

amlgym.util.gen_problems module

amlgym.util.gen_problems.problem_barman(seed=123, num_cocktails=2, num_ingredients=3, num_shots=3)

See util/pddl-generators/barman/README.txt. :type seed: int :param seed: random seed :type num_cocktails: int :param num_cocktails: number of cocktails :type num_ingredients: int :param num_ingredients: number of ingredients :type num_shots: int :param num_shots: number of shots :rtype: str :return: problem string

amlgym.util.gen_problems.problem_blocksworld(seed=123, ops=4, num=3)

See util/pddl-generators/blocksworld/README. :type seed: int :param seed: random seed :type ops: int :param ops: number of operators :type num: int :param num: number of blocks :rtype: str :return: problem string

amlgym.util.gen_problems.problem_childsnack(seed=123, children=1, trays=1, gluten_factor=3, const_ratio=1.3)

See util/pddl-generators/childsnack/README.txt. :type seed: int :param seed: random seed :type children: int :param children: number of children :type trays: int :param trays: number of trays :type gluten_factor: int :param gluten_factor: gluten ratio among children :type const_ratio: int :param const_ratio: proportion of needed symbols that are declared in advance in the problem file. The min ratio should be 1.0 to guarantee solvability. :rtype: str :return: problem string

amlgym.util.gen_problems.problem_depots(e=1, i=1, t=2, p=2, h=2, c=2, seed=123)

See util/pddl-generators/depots/README.txt. :type e: int :param e: number of depots :type i: int :param i: number of distributors :type t: int :param t: number of trucks :type p: int :param p: number of pallets :type h: int :param h: number of hoists :type c: int :param c: number of crates :type seed: int :param seed: random seed :rtype: str :return: problem string

amlgym.util.gen_problems.problem_driverlog(seed=123, road_junctions=1, drivers=1, packages=1, trucks=1)

See util/pddl-generators/driverlog/README.txt. :type seed: int :param seed: random seed :type road_junctions: int :param road_junctions: total number of connections between all location pairs :type drivers: int :param drivers: number of drivers :type packages: int :param packages: number of packages :type trucks: int :param trucks: number of trucks :rtype: str :return: problem string

amlgym.util.gen_problems.problem_elevators(seed=123, floors=2, area_size=2, fast_elevators=1, slow_elevators=1, fast_capacity=1, slow_capacity=3, passengers=2)

See util/pddl-generators/elevators/README.txt. :type seed: int :param seed: random seed :type floors: int :param floors: number of floors :type area_size: int :param area_size: area size (must be a factor of floors, otherwise passengers can start in out of bounds floors) :type fast_elevators: int :param fast_elevators: number of fast elevators :type slow_elevators: int :param slow_elevators: number of slow elevators :type fast_capacity: int :param fast_capacity: passengers capacity of every fast elevators :type slow_capacity: int :param slow_capacity: passengers capacity of every slow elevators :type passengers: int :param passengers: number of passengers :rtype: str :return: problem string

amlgym.util.gen_problems.problem_ferry(seed=123, l=2, c=1)

See util/pddl-generators/ferry/README.txt. :type seed: int :param seed: random seed :type l: int :param l: number of locations :type c: int :param c: number of cars :rtype: str :return: problem string

amlgym.util.gen_problems.problem_floortile(seed=123, num_rows=2, num_columns=2, num_robots=2, mode_flag='seq')

See util/pddl-generators/floortile/README.txt. :type seed: int :param seed: random seed :type num_rows: int :param num_rows: number of rows :type num_columns: int :param num_columns: number of columns :type num_robots: int :param num_robots: number of robots :type mode_flag: str :param mode_flag: either seq or time :rtype: str :return: problem string

amlgym.util.gen_problems.problem_goldminer(seed=123, r=2, c=2)

See util/pddl-generators/goldminer/README. :type seed: int :param seed: random seed :type r: int :param r: number of rows :type c: int :param c: number of columns :rtype: str :return: problem string

amlgym.util.gen_problems.problem_grid(seed=123, x=1, y=1, t=1, p=array([100]), k=array([1]), l=array([1]))

See util/pddl-generators/grid/README. :type seed: int :param seed: random seed :type x: int :param x: horizontal extension of grid :type y: int :param y: vertical extension of grid :type t: int :param t: number of different key and lock types :type p: List[int] :param p: probability, for any key, to be mentioned in the goal :type k: List[int] :param k: number of keys vector (one 0 … 9 entry for each type) :type l: List[int] :param l: number of locks vector (one 0 … 9 entry for each type) :rtype: str :return: problem string

amlgym.util.gen_problems.problem_grippers(seed=123, n=1, r=1, o=1)

See util/pddl-generators/grippers/README.txt. :type seed: int :param seed: random seed :type n: int :param n: number of robots :type r: int :param r: number of rooms :type o: int :param o: number of balls :rtype: str :return: problem string

amlgym.util.gen_problems.problem_hanoi(seed=123, n=1)

See util/pddl-generators/hanoi/README.txt. :type seed: int :param seed: random seed (not used since the problems generator is not randomized) :type n: int :param n: number of discs :rtype: str :return: problem string

amlgym.util.gen_problems.problem_matchingbw(seed=123, n=1)

See util/pddl-generators/hanoi/README.txt. :type seed: int :param seed: random seed :type n: int :param n: number of blocks :rtype: str :return: problem string

amlgym.util.gen_problems.problem_miconic(seed=123, f=1, p=1)

See util/pddl-generators/miconic/README.txt. :type seed: int :param seed: random seed :type f: int :param f: number of floors :type p: int :param p: number of passengers :rtype: str :return: problem string

amlgym.util.gen_problems.problem_nomystery(seed=123, l=1, p=1, n=1, m=1, c=1)

See util/pddl-generators/nomystery/README.txt. :type seed: int :param seed: random seed :type l: int :param l: number of locations :type p: int :param p: number of packages :type n: int :param n: edges ratio in location graph (i.e. total edges = n * l) :type m: int :param m: maximum edges weight :type c: int :param c: constrainedness (initial fuel supply = c * optimal_cost) :rtype: str :return: problem string

amlgym.util.gen_problems.problem_npuzzle(seed=123, n=1)

See util/pddl-generators/npuzzle/README.txt. :type seed: int :param seed: random seed :type n: int :param n: number of rows/columns :rtype: str :return: problem string

amlgym.util.gen_problems.problem_parking(seed=123, curbs=1, cars=1)

See util/pddl-generators/parking/README.txt. :type seed: int :param seed: random seed :type curbs: int :param curbs: number of curbs :type cars: int :param cars: number of cars :rtype: str :return: problem string

amlgym.util.gen_problems.problem_rovers(seed=123, r=1, w=1, o=1, c=1, g=1)

See util/pddl-generators/rovers/README. :type seed: int :param seed: random seed :type r: int :param r: number of rovers :type w: int :param w: number of waypoints :type o: int :param o: number of objectives :type c: int :param c: number of cameras :type g: int :param g: number of goals :rtype: str :return: problem string

amlgym.util.gen_problems.problem_satellite(seed=123, s=1, i=1, m=1, t=1, o=1)

See util/pddl-generators/satellite/README. :type seed: int :param seed: random seed :type s: int :param s: number of satellites :type i: int :param i: maximum number of instruments :type m: int :param m: number of modes :type t: int :param t: number of targets :type o: int :param o: number of observations :rtype: str :return: problem string

amlgym.util.gen_problems.problem_sokoban(seed=123, n=1, b=1, w=1)

See util/pddl-generators/sokoban/README.txt. :type seed: int :param seed: random seed :type n: int :param n: grid size :type b: int :param b: number of boxes :type w: int :param w: number of walls :rtype: str :return: problem string

amlgym.util.gen_problems.problem_spanner(seed=123, spanners=1, nuts=1, locations=3)

See util/pddl-generators/spanner/README.txt. :type seed: int :param seed: random seed :type spanners: int :param spanners: number of spanners :type nuts: int :param nuts: number of nuts :type locations: int :param locations: number of locations :rtype: str :return: problem string

amlgym.util.gen_problems.problem_tpp(seed=123, p=1, m=1, t=3, d=3, l=3)

See util/pddl-generators/tpp/README. :type seed: int :param seed: random seed :type p: int :param p: number of products :type m: int :param m: number of markets :type t: int :param t: number of trucks :type d: int :param d: number of depots :type l: int :param l: maximum goods level :rtype: str :return: problem string

amlgym.util.gen_problems.problem_transport(seed=123, generator='city', n=1, size=10, degree=3, mindistance=10, trucks=3, packages=3)

See util/pddl-generators/transport/README.txt. :type seed: int :param seed: random seed :type generator: str :param generator: transport generator type in [city, two-cities, three-cities] :type n: int :param n: number of nodes :type size: int :param size: size for computing connect_distance = math.sqrt((degree * size * size) / (nodes * math.pi * 0.694)) :type degree: int :param degree: degree for computing connect_distance = math.sqrt((degree * size * size) / (nodes * math.pi * 0.694)) :type mindistance: int :param mindistance: minimum distance between two nodes :type trucks: int :param trucks: number of trucks :type packages: int :param packages: number of packages :rtype: str :return: problem string

amlgym.util.gen_problems.problem_visitall(seed=123, x=3, y=3, r=0.2, u=2)

See util/pddl-generators/visitall/README.txt. :type seed: int :param seed: random seed :type x: int :param x: number of grid cols :type y: int :param y: number of grid rows :type r: int :param r: ratio of cells to be visited :type u: int :param u: number of unavailable grid cells :rtype: str :return: problem string

amlgym.util.gen_problems.problem_zenotravel(seed=123, cities=1, planes=1, people=3, distance=1)

See util/pddl-generators/zenotravel/README. :type seed: int :param seed: random seed :type cities: int :param cities: number of cities :type planes: int :param planes: number of planes :type people: int :param people: number of people :type distance: int :param distance: numerical distance between cities :rtype: str :return: problem string

amlgym.util.gen_probs_solving module

amlgym.util.gen_states_predictability module

amlgym.util.gen_states_predictability.generate_traj(problem, randomness=0.2)

Return type:

Trajectory

amlgym.util.gen_states_predictability.replan(problem, current_state, action_instance)

Check action execution does not make the problem unsolvable by simulating the action and computing a new plan :type problem: Problem :param problem: solvable problem :param action: action to be executed :rtype: any :return: new plan (if any)

amlgym.util.gen_trajs_learning module

amlgym.util.gen_trajs_learning.generate_traj(problem, randomness=0.2)

Return type:

Trajectory

amlgym.util.gen_trajs_learning.replan(problem, current_state, action_instance)

Check action execution does not make the problem unsolvable by simulating the action and computing a new plan :type problem: Problem :param problem: solvable problem :param action: action to be executed :rtype: any :return: new plan (if any)

amlgym.util.gen_trajs_learning_hard module

amlgym.util.gen_trajs_learning_hard.generate_traj(problem, randomness=0.2)

Return type:

Trajectory

amlgym.util.gen_trajs_learning_hard.replan(problem, current_state, action_instance)

Check action execution does not make the problem unsolvable by simulating the action and computing a new plan :type problem: Problem :param problem: solvable problem :param action: action to be executed :rtype: any :return: new plan (if any)

amlgym.util.gen_trajs_predictability module

amlgym.util.gen_trajs_predictability.generate_traj(problem, randomness=0.2)

Return type:

Trajectory

amlgym.util.gen_trajs_predictability.replan(problem, current_state, action_instance)

Check action execution does not make the problem unsolvable by simulating the action and computing a new plan :type problem: Problem :param problem: solvable problem :param action: action to be executed :rtype: any :return: new plan (if any)

amlgym.util.util module

amlgym.util.util.compare_trajs(traj_dir1='../benchmarks/trajectories', traj_dir2='../benchmarks/trajectoriesbkp')

Compare trajectories between two sets of trajectories. :type traj_dir1: str :param traj_dir1: directory with the first set of trajectories :type traj_dir2: str :param traj_dir2: directory with the second set of trajectories

Return type:

None

amlgym.util.util.empty_domain(domain_path, empty_domain_path='empty.pddl')

amlgym.util.util.fix_domain_format(dom_dir='../benchmarks/domains')

Replace “word-word” with “word_word”, otherwise unified-planning does not correctly write the problem file :type dom_dir: str :param dom_dir: directory of domains :rtype: None :return:

amlgym.util.util.get_applicable_actions_val(problem_file, domain_file)

amlgym.util.util.preprocess_trace(traj_path)

Return type:

None

amlgym.util.util.print_actions_with_no_effs(traj_dir='../benchmarks/trajectories')

Compare trajectories between two sets of trajectories. :type traj_dir: str :param traj_dir: directory with the set of trajectories :rtype: None :return:

amlgym.util.util.reduce_problem_settings(in_problem_path, out_problem_path)

Return type:

None

amlgym.util.util.remove_trajs(traj_dir, num=inf)

Remove trajectories with an ID higher than the given one. :type traj_dir: str :param traj_dir: directory with the set of trajectories :param traj_dir: maximum number of trajectories :rtype: None :return:

Module contents