mathrandom-progressive.py

import random
import json
import operator
import math

num_samples = [20000, 50000, 230000, 500000]
min_values = [-9.99, -19.99, -99.99, -99.99]
max_values = [9.99, 19.99, 99.99, 99.99]
vals_floats = ["%.2f", "%.3f", "%.3f", "%.4f"]
result_floats = ["%.2f", "%.3f", "%.4f", "%.4f"]
seed = 42

random.seed(seed)

# Binary operations
binary_operations = {
    '+': operator.add,
    '-': operator.sub,
    '*': operator.mul,
    '/': operator.truediv,
    #'**': operator.pow, # it makes tons of troubles, but if u wanna contribute with a functional fix (L)
    '%': operator.mod
}

# Safe division to avoid division by zero
def safe_division(numerator, denominator):
    return numerator if denominator == 0 else numerator / denominator

# Unary operations
def safe_sqrt(x):
    return math.sqrt(x) if x >= 0 else 0

def safe_log(x):
    return math.log(x) if x > 0 else 0

unary_operations = {
    'sqrt': safe_sqrt,
    'sin': math.sin,
    'cos': math.cos,
    'log': safe_log
}

def format_result(result, format_spec):
    if isinstance(result, complex):
        real_part = format_spec % result.real
        imag_part = format_spec % result.imag
        return f"{real_part} + {imag_part}j"
    else:
        return format_spec % result

def safe_modulo(numerator, denominator):
    return 0 if denominator == 0 else numerator % denominator

def safe_power(base, exponent):
    if base == 0 and exponent < 0:
        return 0  # or some other value that signifies an undefined operation
    else:
        return base ** exponent

def generate_sub_expression(min_value, max_value, val_float):
    num1 = float(val_float % random.uniform(min_value, max_value))
    num2 = float(val_float % random.uniform(min_value, max_value))
    operation = random.choice(list(binary_operations.keys()))

    if operation == '/':
        result = safe_division(num1, num2)
    elif operation == '%':
        result = safe_modulo(num1, num2)
    else:
        result = binary_operations[operation](num1, num2)

    expression = f"({num1} {operation} {num2})"
    return expression, result

def generate_expression(num_samples, min_value, max_value, val_float, result_float):
    data = []
    for _ in range(num_samples):
        sub_ops_count = random.randint(0, 2)  # Number of sub-operations (0, 1, or 2), the code is not tailored for more cases, but feel free to improve it.
        sub_expressions = [generate_sub_expression(min_value, max_value, val_float) for _ in range(sub_ops_count)]

        # Main operation
        main_num1 = float(val_float % random.uniform(min_value, max_value))
        main_num2 = float(val_float % random.uniform(min_value, max_value))
        main_operation = random.choice(list(binary_operations.keys()))

        # Embed sub-expressions into main expression
        if sub_expressions:
            if len(sub_expressions) == 1:
                sub_expr, sub_result = sub_expressions[0]
                if random.choice([True, False]):
                    main_expression = f"{sub_expr} {main_operation} {main_num2}"
                    if main_operation == '/':
                        main_result = safe_division(sub_result, main_num2)
                    elif main_operation == '%':
                        main_result = safe_modulo(sub_result, main_num2)
                    else:
                        main_result = binary_operations[main_operation](sub_result, main_num2)
                else:
                    main_expression = f"{main_num1} {main_operation} {sub_expr}"
                    if main_operation == '/':
                        main_result = safe_division(main_num1, sub_result)
                    elif main_operation == '%':
                        main_result = safe_modulo(main_num1, sub_result)
                    else:
                        main_result = binary_operations[main_operation](main_num1, sub_result)
            else:
                sub_expr1, sub_result1 = sub_expressions[0]
                sub_expr2, sub_result2 = sub_expressions[1]
                main_expression = f"{sub_expr1} {main_operation} {sub_expr2}"
                if main_operation == '/':
                    main_result = safe_division(sub_result1, sub_result2)
                elif main_operation == '%':
                    main_result = safe_modulo(sub_result1, sub_result2)
                else:
                    main_result = binary_operations[main_operation](sub_result1, sub_result2)
        else:
            main_expression = f"{main_num1} {main_operation} {main_num2}"
            if main_operation == '/':
                main_result = safe_division(main_num1, main_num2)
            elif main_operation == '%':
                main_result = safe_modulo(main_num1, main_num2)
            else:
                main_result = binary_operations[main_operation](main_num1, main_num2)

        output = format_result(main_result, result_float)
        data.append({'instruction': main_expression, 'output': output})

    return data


# DPO (Follows Ultrabinarized Format)
def make_prompt(expression, output):
    prompt = {
        'prompt': 'What is the result of the following expression?',
        'chosen': [],
        'rejected': [],
        'messages': []
    }
    prompt['chosen'].append({'content': prompt['prompt'] + '\n' + expression, 'role': 'user'})
    prompt['chosen'].append({'content': output, 'role': 'assistant'})
    prompt['rejected'].append({'content': prompt['prompt'] + '\n' + expression, 'role': 'user'})
    prompt['rejected'].append({'content': output[0:2], 'role': 'assistant'})
    prompt['messages'].append({'content': prompt['prompt'] + '\n' + expression, 'role': 'user'})
    prompt['messages'].append({'content': output, 'role': 'assistant'})
    return prompt


# Generate and write data for each set of parameters
for idx, sample_count in enumerate(num_samples):
    data = generate_expression(sample_count, min_values[idx], max_values[idx], vals_floats[idx], result_floats[idx])
    dpo_data = [make_prompt(elem['instruction'], elem['output']) for elem in data]
    out_file = f'arithmetic-float-complex_{idx}.json'
    with open(out_file, 'w') as f:
        json.dump(data, f)
    out_file = f'arithmetic-float-complex_DPO_{idx}.json'
    with open(out_file, 'w') as f:
        json.dump(dpo_data, f)