browsergym-workarena 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

browsergym/workarena/tasks/compositional/utils/curriculum.py

@@ -0,0 +1,215 @@
+# from .edit_knowledge_base import __TASKS__ as EDIT_KNOWLEDGE_BASE_TASKS, __L2_TASKS__ as EDIT_KNOWLEDGE_BASE_L2_TASKS, __L3_TASKS__ as EDIT_KNOWLEDGE_BASE_L3TASKS
+from ..dash_do_catalog import (
+    DASH_AND_ORDER,
+    DASH_COMPUTE_MEAN_AND_ORDER,
+    DASH_COMPUTE_MEDIAN_AND_ORDER,
+    DASH_COMPUTE_MODE_AND_ORDER,
+)
+from ..dash_do_create_incident import DASH_AND_CREATE_INCIDENT, DASH_COMPUTE_AND_CREATE_INCIDENT
+from ..dash_do_create_problem import DASH_AND_CREATE_PROBLEM, DASH_COMPUTE_AND_CREATE_PROBLEM
+from ..dash_do_filter import (
+    DASH_COMPUTE_MIN_FILTER_LIST,
+    DASH_COMPUTE_MAX_FILTER_LIST,
+    DASH_COMPUTE_MEAN_FILTER_LIST,
+    DASH_COMPUTE_MEDIAN_FILTER_LIST,
+    DASH_COMPUTE_MODE_FILTER_LIST,
+)
+from ..dash_do_request_item import (
+    DASH_AND_REQUEST,
+    DASH_COMPUTE_MEAN_AND_REQUEST,
+    DASH_COMPUTE_MEDIAN_AND_REQUEST,
+    DASH_COMPUTE_MODE_AND_REQUEST,
+)
+from ..expense_management import __TASKS__ as EXPENSE_MANAGEMENT_TASKS
+from ..find_and_order_item import __TASKS__ as FIND_AND_ORDER_ITEM_TASKS
+from ..manage_change_request_schedule import (
+    SMALL_BASE_SCHEDULING_TASKS,
+    LARGE_BASE_SCHEDULING_TASKS,
+    SMALL_TIGHT_SCHEDULING_TASKS,
+    LARGE_TIGHT_SCHEDULING_TASKS,
+)
+from ..mark_duplicate_problems import __TASKS__ as MARK_DUPLICATE_PROBLEMS_TASKS
+from ..maximize_investment_return import __TASKS__ as MAXIMIZE_INVESTMENT_RETURN_TASKS
+from ..navigate_and_do import (
+    NAVIGATE_AND_CREATE_TASKS,
+    NAVIGATE_AND_FILTER_TASKS,
+    NAVIGATE_AND_ORDER_TASKS,
+    NAVIGATE_AND_SORT_TASKS,
+)
+from ..navigate_and_do_infeasible import (
+    INFEASIBLE_NAVIGATE_AND_CREATE_WITH_REASON,
+    INFEASIBLE_NAVIGATE_AND_CREATE,
+    INFEASIBLE_NAVIGATE_AND_ORDER_WITH_REASON,
+    INFEASIBLE_NAVIGATE_AND_ORDER,
+    INFEASIBLE_NAVIGATE_AND_FILTER_WITH_REASON,
+    INFEASIBLE_NAVIGATE_AND_FILTER,
+    INFEASIBLE_NAVIGATE_AND_SORT_WITH_REASON,
+    INFEASIBLE_NAVIGATE_AND_SORT,
+)
+from ..offboard_user import __TASKS__ as OFFBOARD_USER_TASKS
+from ..onboard_user import __TASKS__ as ONBOARD_USER_TASKS
+from ..warranty_check import __TASKS__ as WARRANTY_CHECK_TASKS
+from ..work_assignment import __TASKS__ as WORK_ASSIGNMENT_TASKS
+from ..workload_balancing import __TASKS__ as WORKLOAD_BALANCING_TASKS
+
+AGENT_CURRICULUM = {
+    "planning_and_problem_solving": {
+        "buckets": [
+            MARK_DUPLICATE_PROBLEMS_TASKS,
+            WORKLOAD_BALANCING_TASKS,
+            WORK_ASSIGNMENT_TASKS,
+            SMALL_BASE_SCHEDULING_TASKS,
+            LARGE_BASE_SCHEDULING_TASKS,
+            SMALL_TIGHT_SCHEDULING_TASKS,
+            LARGE_TIGHT_SCHEDULING_TASKS,
+        ],
+        "num_seeds": 2,
+        "weights": [9, 3, 6, 1, 1, 1, 1],
+    },
+    "information_retrieval": {
+        "buckets": [
+            DASH_AND_ORDER,
+            DASH_AND_CREATE_INCIDENT,
+            DASH_AND_CREATE_PROBLEM,
+            DASH_COMPUTE_MIN_FILTER_LIST,
+            DASH_COMPUTE_MAX_FILTER_LIST,
+            DASH_AND_REQUEST,
+            WARRANTY_CHECK_TASKS,
+            FIND_AND_ORDER_ITEM_TASKS,
+        ],
+        "num_seeds": 7,
+        "weights": [1, 1, 1, 1, 1, 1, 1, 1],
+    },
+    "data_driven_decision_making_and_reasoning": {
+        "buckets": [
+            EXPENSE_MANAGEMENT_TASKS,
+            MAXIMIZE_INVESTMENT_RETURN_TASKS,
+            DASH_COMPUTE_MEAN_AND_ORDER,
+            DASH_COMPUTE_MEDIAN_AND_ORDER,
+            DASH_COMPUTE_MODE_AND_ORDER,
+            DASH_COMPUTE_AND_CREATE_INCIDENT,
+            DASH_COMPUTE_AND_CREATE_PROBLEM,
+            DASH_COMPUTE_MEAN_FILTER_LIST,
+            DASH_COMPUTE_MEDIAN_FILTER_LIST,
+            DASH_COMPUTE_MODE_FILTER_LIST,
+            DASH_COMPUTE_MEAN_AND_REQUEST,
+            DASH_COMPUTE_MEDIAN_AND_REQUEST,
+            DASH_COMPUTE_MODE_AND_REQUEST,
+        ],
+        "num_seeds": 1,
+        "weights": [12, 28, 1, 1, 1, 3, 3, 1, 1, 1, 1, 1, 1],
+    },
+    "sophisticated_memory": {
+        "buckets": [
+            NAVIGATE_AND_CREATE_TASKS,
+            NAVIGATE_AND_ORDER_TASKS,
+            NAVIGATE_AND_FILTER_TASKS,
+            NAVIGATE_AND_SORT_TASKS,
+            OFFBOARD_USER_TASKS,
+            ONBOARD_USER_TASKS,
+        ],
+        "num_seeds": 8,
+        "weights": [1, 1, 1, 1, 1, 1],
+    },
+    "contextual_understanding_infeasible_tasks": {
+        "buckets": [
+            INFEASIBLE_NAVIGATE_AND_CREATE_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_CREATE,
+            INFEASIBLE_NAVIGATE_AND_ORDER_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_ORDER,
+            INFEASIBLE_NAVIGATE_AND_FILTER_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_FILTER,
+            INFEASIBLE_NAVIGATE_AND_SORT_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_SORT,
+        ],
+        "num_seeds": 4,
+        "weights": [1, 1, 1, 1, 1, 1, 1, 1],
+    },
+}
+
+HUMAN_CURRICULUM = {
+    "planning_and_problem_solving": {
+        "buckets": [
+            MARK_DUPLICATE_PROBLEMS_TASKS,
+            WORKLOAD_BALANCING_TASKS,
+            WORK_ASSIGNMENT_TASKS,
+            SMALL_BASE_SCHEDULING_TASKS,
+            SMALL_TIGHT_SCHEDULING_TASKS,
+        ],
+        "num_seeds": 1,
+        "weights": [
+            3,
+            1,
+            2,
+            1,
+            1,
+        ],
+    },
+    "information_retrieval": {
+        "buckets": [
+            DASH_AND_ORDER,
+            DASH_AND_CREATE_INCIDENT,
+            DASH_AND_CREATE_PROBLEM,
+            DASH_COMPUTE_MIN_FILTER_LIST,
+            DASH_COMPUTE_MAX_FILTER_LIST,
+            DASH_AND_REQUEST,
+            WARRANTY_CHECK_TASKS,
+            FIND_AND_ORDER_ITEM_TASKS,
+        ],
+        "num_seeds": 1,
+        "weights": [1, 1, 1, 1, 1, 1, 1, 1],
+    },
+    "data_driven_decision_making_and_reasoning": {
+        "buckets": [
+            EXPENSE_MANAGEMENT_TASKS,
+            MAXIMIZE_INVESTMENT_RETURN_TASKS,  # Not splitting as small multiplier
+            [
+                *DASH_COMPUTE_MEAN_AND_ORDER,
+                *DASH_COMPUTE_MEDIAN_AND_ORDER,
+                *DASH_COMPUTE_MODE_AND_ORDER,
+            ],
+            [
+                *DASH_COMPUTE_AND_CREATE_INCIDENT,
+                *DASH_COMPUTE_AND_CREATE_PROBLEM,
+                *DASH_COMPUTE_MEAN_AND_REQUEST,
+            ],
+            DASH_COMPUTE_MEAN_FILTER_LIST,
+            [
+                *DASH_COMPUTE_MEDIAN_FILTER_LIST,
+                *DASH_COMPUTE_MODE_FILTER_LIST,
+            ],
+            [
+                *DASH_COMPUTE_MEDIAN_AND_REQUEST,
+                *DASH_COMPUTE_MODE_AND_REQUEST,
+            ],
+        ],
+        "num_seeds": 1,
+        "weights": [2, 6, 1, 1, 1, 1, 1],
+    },
+    "sophisticated_memory": {
+        "buckets": [
+            NAVIGATE_AND_CREATE_TASKS,
+            NAVIGATE_AND_ORDER_TASKS,
+            NAVIGATE_AND_FILTER_TASKS,
+            NAVIGATE_AND_SORT_TASKS,
+            OFFBOARD_USER_TASKS,
+            ONBOARD_USER_TASKS,
+        ],
+        "num_seeds": 2,
+        "weights": [1, 1, 1, 1, 1, 1],
+    },
+    "contextual_understanding_infeasible_tasks": {
+        "buckets": [
+            INFEASIBLE_NAVIGATE_AND_CREATE_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_CREATE,
+            INFEASIBLE_NAVIGATE_AND_ORDER_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_ORDER,
+            INFEASIBLE_NAVIGATE_AND_FILTER_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_FILTER,
+            INFEASIBLE_NAVIGATE_AND_SORT_WITH_REASON,
+            INFEASIBLE_NAVIGATE_AND_SORT,
+        ],
+        "num_seeds": 1,
+        "weights": [1, 1, 1, 1, 1, 1, 1, 1],
+    },
+}

browsergym/workarena/tasks/compositional/utils/infeasible_configs.py

@@ -0,0 +1,151 @@
+import numpy as np
+
+from faker import Faker
+
+fake = Faker()
+
+
+def get_infeasible_form_config(config, random: np.random, provide_reason: bool = True):
+    """
+    Get an infeasible form config from a feasible config by replacing the name of one of the task_fields with a random word
+
+    Args:
+    --------
+    config (dict):
+        The feasible form config to be transformed into an infeasible one
+    random (np.random):
+        The random number generator to use
+    provide_reason (bool):
+        Whether to provide a reason for the infeasibility. If False, the list of reasons will be [""] so that
+        any infeasibility can be detected by the absence of a reason
+
+    Returns:
+    --------
+    infeasible_config (dict):
+        The infeasible form config
+    infeasible_keywords (list[str]):
+        The name of the new field printed and its system name
+    """
+    replaced_field = (
+        random.choice(config["infeasible_task_fields"])
+        if "infeasible_task_fields" in config
+        else random.choice(config["task_fields"])
+    )
+    new_field_printed = fake.word().capitalize() + " " + fake.word()
+    new_field_system_name = new_field_printed.lower().replace(" ", "_")
+
+    config["task_fields"].remove(replaced_field)
+    config["task_fields"].append(new_field_system_name)
+    config["fields"][new_field_system_name] = new_field_printed
+    config["template_record"][new_field_system_name] = fake.word()
+
+    infeasible_reasons = [new_field_printed, new_field_system_name] if provide_reason else [""]
+
+    return config, infeasible_reasons
+
+
+def get_infeasible_service_catalog_config(config, random: np.random, provide_reason: bool = True):
+    """
+    Get an infeasible service catalog config from a feasible config by replacing the name of one of the additional configuration items with a random word
+
+    Args:
+    --------
+    config (dict):
+        The feasible service catalog config to be transformed into an infeasible one
+    random (np.random):
+        The random number generator to use
+    provide_reason (bool):
+        Whether to provide a reason for the infeasibility. If False, the list of reasons will be [""] so that
+        any infeasibility can be detected by the absence of a reason
+
+    Returns:
+    --------
+    infeasible_config (dict):
+        The infeasible service catalog config
+    infeasible_keywords (list[str]):
+        The name of the new field printed and its system name
+    """
+    item_configuration = list(config["configuration"].keys())
+    # if there is a configuration item, replace it with a new one; otherwise, simply add a new one
+    if item_configuration:
+        replaced_field = random.choice(item_configuration)
+        config["configuration"].pop(replaced_field)
+    new_field_printed = fake.word().capitalize() + " " + fake.word()
+    field_type = random.choice(["radio", "textarea", "checkbox", "select"])
+    field_options = [fake.word() for _ in range(random.randint(2, 5))]
+
+    config["configuration"][new_field_printed] = [field_type, ", ".join(field_options)]
+
+    infeasible_reasons = [new_field_printed, *field_options] if provide_reason else [""]
+
+    return config, infeasible_reasons
+
+
+def get_infeasible_sort_config(config, random: np.random, provide_reason: bool = True):
+    """
+    Get an infeasible sort config from a feasible config by replacing the name of one sort_fields with a random word
+
+    Args:
+    --------
+    config (dict):
+        The feasible sort config to be transformed into an infeasible one
+    random (np.random):
+        The random number generator to use
+    provide_reason (bool):
+        Whether to provide a reason for the infeasibility. If False, the list of reasons will be [""] so that
+        any infeasibility can be detected by the absence of a reason
+
+    Returns:
+    --------
+    infeasible_config (dict):
+        The infeasible sort config
+    infeasible_keywords (list[str]):
+        The name of the new sort option printed and its system name
+    """
+    goal = config["goal"]
+    config_fields = [line[3:].split(" (")[0] for line in goal.split("\n")[1:]]
+    replaced_field_index = random.randint(0, len(config["sort_fields"]))
+
+    new_field_printed = fake.word().capitalize() + " " + fake.word()
+    new_field_system_name = new_field_printed.lower().replace(" ", "_")
+
+    config["goal"] = goal.replace(config_fields[replaced_field_index], new_field_printed)
+    config["sort_fields"][replaced_field_index] = new_field_system_name
+
+    infeasible_reasons = [new_field_printed, new_field_system_name] if provide_reason else [""]
+
+    return config, infeasible_reasons
+
+
+def get_infeasible_filter_config(config, random: np.random, provide_reason: bool = True):
+    """
+    Get an infeasible filter config from a feasible config by replacing the name of one of the filter_columns with a random word
+
+    Args:
+    --------
+    config (dict):
+        The feasible filter config to be transformed into an infeasible one
+    random (np.random):
+        The random number generator to use
+    provide_reason (bool):
+        Whether to provide a reason for the infeasibility. If False, the list of reasons will be [""] so that
+        any infeasibility can be detected by the absence of a reason
+
+    Returns:
+    --------
+    infeasible_config (dict):
+        The infeasible filter config
+    infeasible_keywords (list[str]):
+        The name of the new filter option printed and its system name
+    """
+    replaced_field_index = random.randint(0, len(config["filter_columns"]))
+
+    new_field_printed = fake.word().capitalize() + " " + fake.word()
+    new_field_system_name = new_field_printed.lower().replace(" ", "_")
+    config["filter_columns"][replaced_field_index] = new_field_system_name
+    config["filter_values"][replaced_field_index] = fake.word().capitalize()
+    config["list_info"]["columns"][new_field_system_name] = {"label": new_field_printed}
+
+    infeasible_reasons = [new_field_printed, new_field_system_name] if provide_reason else [""]
+
+    return config, infeasible_reasons

browsergym/workarena/tasks/compositional/utils/knapsack.py

@@ -0,0 +1,192 @@
+import numpy as np
+
+
+class KnapsackInstanceGenarator:
+    """
+    Generates a knapsack instance with the given number of items and maximum capacity, and solves it.
+    The instance is guaranteed to have a unique optimal solution in "random" or "single_item" mode .
+
+    Args:
+    - random: Random number generator
+    - num_items: Number of items
+    - max_capacity: Maximum capacity of the knapsack
+    - mode: Mode of generation. Choice of "random", "trivial", "single_item", "single_item_uniform", "n_items"
+        - random: Randomly generate the instance and return it; guaranteed to have a unique optimal solution
+        - trivial: Generate a trivial instance with all items fitting in the knapsack; return the instance
+        - single_item: Generate an instance where the optimal solution has only one item
+        - n_items: Generate an instance with all items having uniform weight and value; n items fitting in the knapsack
+        - single_item_uniform: Generate an instance with all items having uniform weight and value; optimal solution has only one item and it can be any
+    - num_items_in_solution: Number of items in the optimal solution. Required for "n_items" mode.
+    - default_return: Default return value for investments having uniform weight and value. Required for "n_items" and "single_item_uniform" modes.
+    """
+
+    def __init__(
+        self,
+        random: np.random,
+        num_items: int,
+        max_capacity: int,
+        mode: str = "random",
+        num_items_in_solution: int = None,
+        default_return: int = 100000,
+    ):
+        self.random = random
+        self.num_items = num_items
+        self.max_capacity = max_capacity
+        self.mode = mode
+        self.num_items_in_solution = num_items_in_solution
+        self.default_return = default_return
+
+    def get_instance(self):
+        if self.mode in ["random", "trivial"]:
+            return self.generate_and_solve_knapsack_instance()
+        elif self.mode == "single_item":
+            return self.generate_single_item_knapsack_instance()
+        elif self.mode in ["single_item_uniform", "n_items"]:
+            return self.generate_uniform_knapsack_instance()
+        else:
+            raise ValueError(f"Invalid mode {self.mode} for knapsack instance generation")
+
+    def generate_and_solve_knapsack_instance(self):
+        """
+        Generates a knapsack instance with the given number of items and maximum capacity, and solves it.
+        Used to generate instances for the "random" and "trivial" mode.
+        Returns:
+        - investments: List of tuples (cost, investment_return) for each investment
+        - max_return: Maximum return achievable with optimal solution
+        - selected_indices: Indices of the investments selected in the optimal solution
+        """
+
+        assert self.mode in [
+            "random",
+            "trivial",
+        ], f"Mode {self.mode} is invalid for instance generation with generate_and_solve_knapsack_instance"
+
+        multiple_solutions = True
+        while multiple_solutions:
+            # Generate knapsack instance...
+            investments = []
+            min_cost = self.max_capacity // (self.num_items * 2)
+            max_cost = (
+                self.max_capacity // 2
+                if self.mode == "random"
+                else self.max_capacity // self.num_items
+            )
+            for _ in range(self.num_items):
+                cost = self.random.randint(min_cost, max_cost)
+                # Ensure that investments yield positive returns
+                investment_return = self.random.randint(
+                    self.max_capacity // 2, self.max_capacity // 2 + 40000
+                )
+                investments.append((cost, investment_return))
+
+            total_cost = sum([investments[i][0] for i in range(self.num_items)])
+            # Skip trivial instances where all items fit in the knapsack
+            if self.mode == "random" and total_cost <= self.max_capacity:
+                continue
+
+            if self.mode == "random":
+                # ...Solve it...
+                max_return, num_optimal_solutions, selected_indices = self.solve_knapsack(
+                    investments, self.max_capacity
+                )
+                # ...and check if there are multiple solutions
+                multiple_solutions = num_optimal_solutions > 1
+            else:
+                selected_indices = list(range(self.num_items))
+                max_return = sum([investments[i][1] for i in selected_indices])
+                multiple_solutions = False
+
+        return investments, max_return, selected_indices
+
+    def generate_single_item_knapsack_instance(self):
+        """Generate knapsack instance where the optimal solution contains only one item
+        Returns:
+        - investments: List of tuples (cost, investment_return) for each investment
+        - max_investment_return: Investment return of the selected investment in the optimal solution
+        - selected_indices: Index of the selected investment in the optimal solution
+        """
+        assert (
+            self.mode == "single_item"
+        ), f"Mode {self.mode} is invalid for instance generation with generate_single_item_knapsack_instance"
+
+        # Ensure that the optimal solution contains only one item
+        min_cost = self.max_capacity // 2 + 1
+        max_cost = self.max_capacity - 1
+
+        max_investment_return = 0
+        max_investment_index = 0
+
+        # Generate knapsack instance...
+        investments = []
+        for i in range(self.num_items):
+            cost = self.random.randint(min_cost, max_cost)
+            investment_return = self.random.randint(max_cost, 2 * max_cost)
+
+            # Ensure that the optimal solution contains only one item
+            while investment_return == max_investment_return:
+                investment_return = self.random.randint(max_cost, 2 * max_cost)
+
+            if investment_return > max_investment_return:
+                max_investment_return = investment_return
+                max_investment_index = i
+
+            investments.append((cost, investment_return))
+
+        return investments, max_investment_return, [max_investment_index]
+
+    def generate_uniform_knapsack_instance(self):
+        """Generate knapsack instance where all items have the same cost and return
+        Returns:
+        - investments: List of tuples (cost, investment_return) for each investment
+        - max_return: Maximum return achievable with optimal solution
+        - selected_indices=None: No need to return selected indices as all items have the same cost and return. The validation code should check that
+          the optimal solution contains a subset of the items of the right length.
+        """
+        assert self.mode in [
+            "single_item_uniform",
+            "n_items",
+        ], f"Mode {self.mode} is invalid for instance generation with generate_n_items_knapsack_instance"
+        items_in_solution = self.num_items_in_solution if self.mode == "n_items" else 1
+
+        # Ensure that the optimal solution contains the specified number of items
+        item_weight = self.max_capacity // (items_in_solution + 1) + 1
+        # Generate knapsack instance...
+        investments = [(item_weight, self.default_return) for _ in range(self.num_items)]
+
+        return investments, self.default_return * items_in_solution, None
+
+    def solve_knapsack(self, investments, max_capacity):
+        """Solves the knapsack problem using dynamic programming"""
+        num_investments = len(investments)
+
+        # Initialize DP table for maximum return and number of ways
+        dp = [[(0, 0) for _ in range(max_capacity + 1)] for _ in range(num_investments + 1)]
+
+        for i in range(1, num_investments + 1):
+            cost, return_ = investments[i - 1]
+            for w in range(max_capacity + 1):
+                if cost <= w:
+                    # If adding the current investment yields a higher return, update the cell
+                    if return_ + dp[i - 1][w - cost][0] > dp[i - 1][w][0]:
+                        dp[i][w] = (return_ + dp[i - 1][w - cost][0], 1)
+                    # If it yields the same return, add the number of ways from the cell without the current investment
+                    elif return_ + dp[i - 1][w - cost][0] == dp[i - 1][w][0]:
+                        dp[i][w] = (dp[i - 1][w][0], dp[i - 1][w][1] + dp[i - 1][w - cost][1])
+                    # If it yields a lower return, keep the old maximum return and number of ways
+                    else:
+                        dp[i][w] = dp[i - 1][w]
+                else:
+                    dp[i][w] = dp[i - 1][w]
+
+        # Retrieve the maximum return and the number of ways to achieve it
+        max_return, num_ways = dp[num_investments][max_capacity]
+
+        # Retrieve the indices of the selected investments
+        selected_indices = []
+        w = max_capacity
+        for i in range(num_investments, 0, -1):
+            if dp[i][w] != dp[i - 1][w]:
+                selected_indices.append(i - 1)
+                w -= investments[i - 1][0]
+
+        return max_return, num_ways, selected_indices