Update mathrandom-progressive.py

mathrandom-progressive.py

@@ -1,46 +1,157 @@
 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"]
-operations = {
+seed = 42
+
+random.seed(seed)
+
+# Binary operations
+binary_operations = {
     '+': operator.add,
     '-': operator.sub,
     '*': operator.mul,
-    '/': operator.truediv
+    '/': 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
 
-for idx, _ in enumerate(num_samples):
+# 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[idx]):
-        num1, num2, num3 = None, None, None
-        while num1 in [None, 0., -0.] or num2 in [None, 0., -0.] or num3 in [None, 0., -0.]:
-            num1 = float(vals_floats[idx] % random.uniform(min_values[idx], max_values[idx]))
-            num2 = float(vals_floats[idx] % random.uniform(min_values[idx], max_values[idx]))
-            num3 = float(vals_floats[idx] % random.uniform(min_values[idx], max_values[idx]))
-
-        operation1 = random.choice(list(operations.keys()))
-        operation2 = random.choice(list(operations.keys()))
-
-        if random.choice([True, False]):
-            expression = f"({num1} {operation1} {num2}) {operation2} {num3}"
-            intermediate_result = safe_division(num1, num2) if operation1 == '/' else operations[operation1](num1, num2)
-            result = safe_division(intermediate_result, num3) if operation2 == '/' and intermediate_result != 0 else operations[operation2](intermediate_result, num3)
+    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:
-            expression = f"{num1} {operation1} {num2} {operation2} {num3}"
-            intermediate_result = safe_division(num1, num2) if operation1 == '/' else operations[operation1](num1, num2)
-            result = safe_division(intermediate_result, num3) if operation2 == '/' else operations[operation2](intermediate_result, num3)
+            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})
 
-        output = result_floats[idx] % result
-        data.append({'instruction': 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)
+        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)