comprehensive-arithmetic-problems.py

## Adapted from https://github.com/maxwbuckley/r2ltokenizing/blob/main/llmarithmetic.py; with modifications
import random
from datasets import (
    BuilderConfig,
    SplitGenerator,
    GeneratorBasedBuilder,
    DatasetInfo,
    Value,
    Features,
)
from decimal import Decimal
import yaml

SEED = 42
TEST_SIZE = 0.2
DIVISION_RESULT_MULTIPLIER = 4
FLOAT_FLOAT_PROBLEM_PROPORTION = 0.3

_CITATION = """\
@misc{lee2024arithmeticproblemsdataset,
title = {Arithmetic Problems},
author={Garreth Lee},
year={2024}
}
"""



class Operator:
    ADD = "+"
    SUBTRACT = "-"
    MULTIPLY = "*"
    DIVIDE = "/"

    OPERATORS = [ADD, SUBTRACT, MULTIPLY, DIVIDE]

    @classmethod
    def is_operator(cls, value):
        return value in cls.OPERATORS

    @classmethod
    def operator_to_name(cls, value):
        if value == cls.ADD:
            return "add"
        elif value == cls.SUBTRACT:
            return "subtract"
        elif value == cls.MULTIPLY:
            return "multiply"
        elif value == cls.DIVIDE:
            return "divide"
        else:
            raise ValueError(f"Invalid operator: {value}")


class OperationType:
    INT_INT = [False, False]
    INT_FLOAT = [True, False]
    FLOAT_FLOAT = [True, True]

class ArithmeticProblemsConfig(BuilderConfig):
    def __init__(
        self,
        name: str,
        num_problems: int,
        min_exponent: int,
        max_exponent: int,
        max_rounding_precision: int,
        use_commas: bool = False,
        **kwargs,
    ):
        super().__init__(name=name)
        self.num_problems = num_problems
        self.min_exponent = min_exponent
        self.max_exponent = max_exponent
        self.max_rounding_precision = max_rounding_precision
        self.use_commas = use_commas
        self.kwargs = kwargs




class ArithmeticProblemsDataset(GeneratorBasedBuilder):
    BUILDER_CONFIG_CLASS = ArithmeticProblemsConfig
    FLOAT_ANSWER_ROUNDING_PRECISION = 4

    BUILDER_CONFIGS = [
        ArithmeticProblemsConfig(
            name=f"{i}-digit{'-use-commas' if use_commas else ''}",
            num_problems=5000,
            min_exponent=i-1,
            max_exponent=i,
            max_rounding_precision=max(i-1, 10),
            use_commas = use_commas,
        ) for i in range(1, 21) for use_commas in (True, False)
    ]

    VERSION = "1.0.0"

    def _info(self):
        return DatasetInfo(
            description="Generate arithmetic problems for use in math tokenization",
            features=Features(
                {
                    "question": Value("string"),
                    "answer": Value("string"),
                    "operator": Value("string"),
                }
            ),
            citation=_CITATION,
        )

    def _generate_number(
        self, min_val: int, max_val: int, is_float: bool, max_rounding_precision: int
    ) -> float | int:
        """
        Generates a random number within a specified range, either as an integer or float.

        Args:
        min_val: The minimum value of the range.
        max_val: The maximum value of the range.
        is_float: If true, generates a float
        max_rounding_precision: The maximum precision to use when rounding the number.

        Returns:
        A random number within the specified range, either as an int or a float.
        """
        if is_float:
            # Round to a random precision between 0 and max_rounding_precision
            return round(
                random.uniform(min_val, max_val),
                random.choice(range(1, max_rounding_precision + 1)),
            )
        else:
            return random.randint(min_val, max_val)

    def _format_number(self, number: int | float, use_commas: bool = False) -> str:
        """
        Rounds a number to a specified precision, and then formats it as a string.

        Args:
        number: The number to be formatted.
        use_commas: Whether to include commas as thousand separators.

        Returns:
        A string representation of the input number, rounded to the specified precision.
        """
        if use_commas:
            return "{:,}".format(number)
        else:
            return str(number)

    def _construct_equation(
        self,
        operand1: int | float,
        operand2: int | float,
        operator: str,
        use_commas: bool = False,
    ) -> str:
        """Helper function for constructing the string equations."""

        return "%s %s %s = " % (
            self._format_number(operand1, use_commas),
            operator,
            self._format_number(operand2, use_commas),
        )

    def create_question_answer_pair(
        self,
        min_value: int,
        max_value: int,
        operator: str,
        use_commas: bool,
        operation_type: list[bool],
        max_rounding_precision: int | None,
    ) -> dict[str, str]:
        """Creates a random question and correct answer pair.

        Args:
        min_value: The lowest possible random value.
        max_value: The highest possible random value.
        include_decimals: Whether to include float numbers in the generated problems.
        operator: The mathematical operator to use.
        use_commas: Whether to use commas to separate numbers right-to-left.

        Returns:
        A dictionary containing the equation string and the expected answer.
        """
        if not Operator.is_operator(operator):
            raise ValueError(f"Invalid operator: {operator}")

        is_float1, is_float2 = operation_type
        operand1 = self._generate_number(
            min_val=min_value,
            max_val=max_value,
            is_float=is_float1,
            max_rounding_precision=max_rounding_precision,
        )
        operand2 = self._generate_number(
            min_val=min_value,
            max_val=max_value,
            is_float=is_float2,
            max_rounding_precision=max_rounding_precision,
        )

        if operator == Operator.SUBTRACT:
            result = operand1 - operand2
        elif operator == Operator.ADD:
            result = operand1 + operand2
        elif operator == Operator.MULTIPLY:
            result = operand1 * operand2
        else:
            # this prevents a lot of "0" answers from being generated
            if operand1 < operand2 or random.random() < 0.01:
                operand1, operand2 = operand2, operand1

            if operation_type == OperationType.INT_INT:
                tmp = operand1 / operand2

                # we scale the temp result up to prevent a lot of "small divisions"
                if tmp < 10:
                    tmp *= DIVISION_RESULT_MULTIPLIER
                if max_value > 999:
                    tmp *= random.randint(2, 4)

                # prevents zero division
                operand1 = int(round(tmp)) * operand2
                result = int(operand1 / operand2)

            elif operation_type == OperationType.INT_FLOAT:
                operand2 = int(operand2)
                tmp = round(
                    operand1 / operand2,
                    random.randint(1, max_rounding_precision),
                )

                # we scale the temp result up to prevent a lot of "small divisions"
                if tmp < 10:
                    tmp = float(
                        Decimal(str(tmp)) * Decimal(str(DIVISION_RESULT_MULTIPLIER))
                    )

                # deals with Python's decimal multiplication precision issue
                operand1 = float(Decimal(str(tmp)) * Decimal(str(operand2)))
                result = tmp

            else:
                tmp = round(
                    operand1 / operand2, random.randint(1, max_rounding_precision)
                )

                # we scale the temp result up to prevent a lot of "small divisions"
                if tmp < 10:
                    tmp = float(
                        Decimal(str(tmp)) * Decimal(str(DIVISION_RESULT_MULTIPLIER))
                    )

                # deals with Python's decimal multiplication precision issue
                operand1 = float(Decimal(str(tmp)) * Decimal(str(operand2)))
                result = tmp

        result = round(result, self.FLOAT_ANSWER_ROUNDING_PRECISION)

        question = self._construct_equation(
            operand1=operand1,
            operand2=operand2,
            operator=operator,
            use_commas=use_commas,
        )
        answer = self._format_number(result, use_commas)

        return {"question": question, "answer": answer, "operator": operator}

    def _split_generators(self, dl_manager, **kwargs) -> list[SplitGenerator]:
        generators = []

        for operator in Operator.OPERATORS:
            # Create separate splits for each type of number
            for type in ("int", "float"):
                split_name = f"{type}_{Operator.operator_to_name(operator)}"

                train_generator = SplitGenerator(
                    name=split_name + "_train",
                    gen_kwargs={
                        "num_problems": int(self.config.num_problems * (1 - TEST_SIZE)),
                        "min_value": 10**self.config.min_exponent,
                        "max_value": 10**self.config.max_exponent,
                        "max_rounding_precision": self.config.max_rounding_precision
                        if type == "float"
                        else None,
                        "use_commas": self.config.use_commas,
                        "operator": operator,
                    },
                )

                test_generator = SplitGenerator(
                    name=split_name + "_test",
                    gen_kwargs={
                        "num_problems": int(self.config.num_problems * TEST_SIZE),
                        "min_value": 10**self.config.min_exponent,
                        "max_value": 10**self.config.max_exponent,
                        "max_rounding_precision": self.config.max_rounding_precision
                        if type == "float"
                        else None,
                        "use_commas": self.config.use_commas,
                        "operator": operator,
                    },
                )

                generators.append(train_generator)
                generators.append(test_generator)

        return generators

    def _generate_examples(
        self,
        num_problems,
        min_value,
        max_value,
        max_rounding_precision,
        use_commas,
        operator,
    ):
        def _get_operation_type(current_idx: int):
            # If max_rounding_precision is None, generate only integer problems
            """
            Determines the type of operation (integer-integer, float-float, or integer-float)
            to generate based on the current index and the proportion of float problems.

            Args:
                current_idx: The current index of the problem being generated.
                num_problems: The total number of problems to generate.
                max_rounding_precision: The maximum rounding precision to use when generating float problems.

            Returns:
                An OperationType indicating the type of operation to generate.
            """
            if max_rounding_precision is None:
                return OperationType.INT_INT

            # Otherwise, if the current index is less than the float problem proportion,
            elif current_idx < num_problems * FLOAT_FLOAT_PROBLEM_PROPORTION:
                return OperationType.FLOAT_FLOAT

            else:
                return OperationType.INT_FLOAT

        random.seed(SEED)

        for i in range(num_problems):
            yield (
                str(i),
                self.create_question_answer_pair(
                    min_value=min_value,
                    max_value=max_value,
                    operator=operator,
                    use_commas=use_commas,
                    operation_type=_get_operation_type(i),
                    max_rounding_precision=max_rounding_precision,
                ),
            )