A more complex script generated by gpt4-turbo

README.md

@@ -1,37 +1,19 @@
 ---
 dataset_info:
   features:
-  - name: output
-    dtype: string
   - name: instruction
     dtype: string
+  - name: output
+    dtype: string
   splits:
-  - name: arithmetic.float2_train
-    num_bytes: 645500.3
-    num_examples: 19000
-  - name: arithmetic.float2_valid
-    num_bytes: 33973.7
-    num_examples: 1000
-  - name: arithmetic.float3_train
-    num_bytes: 1890863.85
-    num_examples: 47500
-  - name: arithmetic.float3_valid
-    num_bytes: 99519.15
-    num_examples: 2500
-  - name: arithmetic.float34_train
-    num_bytes: 9321513.05
-    num_examples: 218500
-  - name: arithmetic.float34_valid
-    num_bytes: 490605.95
-    num_examples: 11500
-  - name: arithmetic.float4_train
-    num_bytes: 21671996.6
-    num_examples: 475000
-  - name: arithmetic.float4_valid
-    num_bytes: 1140631.4
-    num_examples: 25000
-  download_size: 27928049
-  dataset_size: 35294604
+  - name: train
+    num_bytes: 15268888.05
+    num_examples: 487500
+  - name: test
+    num_bytes: 391509.95
+    num_examples: 12500
+  download_size: 12160789
+  dataset_size: 15660398.0
 configs:
 - config_name: default
   data_files:
@@ -39,104 +21,49 @@ configs:
     path: data/train-*
   - split: test
     path: data/test-*
-tags:
-- math
-- finance
-license: cc-by-nc-nd-4.0
-task_categories:
-- text-generation
-- question-answering
-pretty_name: Simple Math
-size_categories:
-- 100K<n<1M
 ---
 
-# Simple Math: 2+2=4 -1=3 (LoLo: Learning Only Logical Operations)
+# Simple Math
 
 Just like my teacher gave me homework, i thought maybe we can also add some of these basics on the trainings of our models.
 
-It was created with very simple code that is in the repo, if you add more complex operations and so.. **please share the code** :D thank you
-
-Current Code Version: 20240127.fblgit (A modification over @win10 for progressive and DPO operation)
-![LoLo: Learning Only Logical Operations](https://huggingface.co/datasets/fblgit/simple-math/resolve/main/LOLO.png)
-## Does it Works?
-### 34BEAGLES Evaluation:
-```
-hf (pretrained=/data/models/UNA-34Beagles-v1-final,dtype=bfloat16,trust_remote_code=True), gen_kwargs: (None), limit: None, num_fewshot: None, batch_size: auto (8)
-|    Tasks     |Version|Filter|n-shot| Metric |Value |   |Stderr|
-|--------------|-------|------|-----:|--------|-----:|---|-----:|
-|arc_challenge |Yaml   |none  |    25|acc     |0.7039|±  |0.0133|
-|              |       |none  |    25|acc_norm|0.7321|±  |0.0129|
-|truthfulqa_mc2|Yaml   |none  |     0|acc     |0.7387|±  |0.0141|
-
-hf (pretrained=/data/models/UNA-34Beagles-v1-final,dtype=bfloat16,trust_remote_code=True), gen_kwargs: (None), limit: None, num_fewshot: None, batch_size: auto
-|Tasks|Version|  Filter  |n-shot|  Metric   |Value |   |Stderr|
-|-----|-------|----------|-----:|-----------|-----:|---|-----:|
-|gsm8k|Yaml   |get-answer|     5|exact_match|0.6399|±  |0.0132|
-
-|      Groups      |Version|Filter|n-shot|Metric|Value |   |Stderr|
-|------------------|-------|------|-----:|------|-----:|---|-----:|
-|mmlu              |N/A    |none  |     0|acc   |0.7477|±  |0.1079|
-| - humanities     |N/A    |none  |     0|acc   |0.7188|±  |0.0855|
-| - other          |N/A    |none  |     0|acc   |0.7950|±  |0.1057|
-| - social_sciences|N/A    |none  |     0|acc   |0.8297|±  |0.0664|
-| - stem           |N/A    |none  |     0|acc   |0.6641|±  |0.1291|
-```
-
-### 34BEAGLES-MATH Evaluation
+It was created with this code, if you add more complex operations and so.. please share the code :D thank you
+```py
+import random
+# Define the number of samples you want to generate
+num_samples = 500000
+# Define the range for the random numbers
+min_value = -99.99
+max_value = 99.99
+# Define the arithmetic operations
+operations = ['+', '-', '*', '/']
+# Generate data
+data = []
+for _ in range(num_samples):
+    num1 = float("%.3f" % random.uniform(min_value, max_value))
+    num2 = float("%.3f" % random.uniform(min_value, max_value))
+    while num2 == 0.0:
+         num2 = float("%.3f" % random.uniform(min_value, max_value))
+    while num1 == 0.0:
+         num1 = float("%.3f" % random.uniform(min_value, max_value))
+    operation = random.choice(operations)
+    if operation == '/':
+        result = num1 / num2
+    elif operation == '-':
+        result = num1 - num2
+    elif operation == '*':
+        result = num1 * num2
+    elif operation == '+':
+        result = num1 + num2
+    output = "%.4f" % result
+    instruction = f"{num1} {operation} {num2}"
+    data.append({'instruction': instruction, 'output': output})
+# Create the dataset
+import json
+out_file = 'arithmetic-float4a.json'
+with open(out_file, 'w') as f:
+    json.dump(data, f)
 ```
-hf (pretrained=/data/models/34BeaglesMath-v1,dtype=bfloat16,trust_remote_code=True), gen_kwargs: (None), limit: None, num_fewshot: None, batch_size: auto
-|Tasks|Version|  Filter  |n-shot|  Metric   |Value |   |Stderr|
-|-----|-------|----------|-----:|-----------|-----:|---|-----:|
-|gsm8k|Yaml   |get-answer|     5|exact_match|0.6505|±  |0.0131|
-
-hf (pretrained=/data/models/34BeaglesMath-v1,dtype=bfloat16,trust_remote_code=True), gen_kwargs: (None), limit: None, num_fewshot: None, batch_size: auto (8)
-|    Tasks     |Version|Filter|n-shot| Metric |Value |   |Stderr|
-|--------------|-------|------|-----:|--------|-----:|---|-----:|
-|arc_challenge |Yaml   |none  |    25|acc     |0.7090|±  |0.0133|
-|              |       |none  |    25|acc_norm|0.7329|±  |0.0129|
-|truthfulqa_mc2|Yaml   |none  |     0|acc     |0.7378|±  |0.0141|
 
-|      Groups      |Version|Filter|n-shot|Metric|Value |   |Stderr|
-|------------------|-------|------|-----:|------|-----:|---|-----:|
-|mmlu              |N/A    |none  |     0|acc   |0.7524|±  |0.1045|
-| - humanities     |N/A    |none  |     0|acc   |0.7307|±  |0.0846|
-| - other          |N/A    |none  |     0|acc   |0.7937|±  |0.1029|
-| - social_sciences|N/A    |none  |     0|acc   |0.8274|±  |0.0667|
-| - stem           |N/A    |none  |     0|acc   |0.6708|±  |0.1236|
-```
-
-But it gets better, because when increasing length and complexity, the marks are even superior:
-```
-|Tasks|Version|  Filter  |n-shot|  Metric   |Value |   |Stderr|
-|-----|-------|----------|-----:|-----------|-----:|---|-----:|
-|gsm8k|Yaml   |get-answer|     5|exact_match|0.6611|±  | 0.013|
-```
-On a 3.20% GSM Improvement compared to its base model.
-
-## Note to contributors:
-**thank you to those contributing on the experiment with beautiful commits and good spirit**
-
-* Feel free to contribute on the readme Evaluation tests.
-* Lets aim to build an ablation & paper together. All contributors will be cited.
-
-## Versions
-```
-27.01.24 Added new code to generate the dataset, seed 42 and now also generates DPO.
-24.01.24 Added gradual complexity on a separate script
-20-23.01.24 Multiple contributions with operations and increased complexity on the main generator script.
-```
-
-## Citations
 If you use Simple Math o train your model, please cite on the modelcard or the paper.
-
-```
-@misc{simplemath,
-  title={Simple-Math: 2+2=4 4-1=3}, 
-  author={Xavier Murias},
-  year={2024},
-  publisher = {Juanako.AI},
-  journal = {HuggingFace repository},
-  howpublished = {\url{https://huggingface.co/datasets/fblgit/simple-math}},
-}
-```
+Thank you

data/arithmetic.float2_train-00000-of-00001-76d20691102f37a0.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ac883ac351f437ca03f3a0dbbc1c1f3f2d659354f2a06248ff87cdbc29c9843a
-size 436655

data/arithmetic.float2_valid-00000-of-00001-4da290d9dd516e56.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e0cb741de82b162d98f9fd6b013aae7e31421dd416ea4060db3eebf51b2d7e24
-size 23926

data/arithmetic.float34_train-00000-of-00001-675d1a6d12dd2773.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:47f74ed658777edd68f302c8ac0ba4eabe16b9522b37d934ff897491a4c0788a
-size 7229970

data/arithmetic.float34_valid-00000-of-00001-6361402bfe44060c.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e21f7c213473e4988429f826bfbd8c546d7acaf28c6f494e808bdc5f46676bbf
-size 381872

data/arithmetic.float3_train-00000-of-00001-e20ff809970b0270.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:055dfc6aa0896895e5b644b338e9a32757c8e1dc4bbcbd54cff5800057520f5c
-size 1383635

data/arithmetic.float3_valid-00000-of-00001-69ca851e549f4b06.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b285631b13c0ac2d921c1eceda32538e4210b5c25b47c0a87e86a706f109800e
-size 74022

data/arithmetic.float4_train-00000-of-00001-e6ab9284e13e1f0c.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d7157baa3a95e306ca4b192f366ad7d47430f5c5638fbaaf8feeada2f4859650
-size 17476607

data/arithmetic.float4_valid-00000-of-00001-badf2cf4b2557733.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0361ad345ba73a9dfbc40eceb4f0626ce3ef59fc65bb23442a11f62e2214e482
-size 921362

mathrandom-progressive.py

@@ -1,157 +0,0 @@
-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)

mathrandom2.py

@@ -1,70 +0,0 @@
-import random
-import json
-import operator
-
-# Define the number of samples you want to generate
-num_samples = 500000
-# Define the range for the random numbers
-min_value = -99.99
-max_value = 99.99
-# Define the arithmetic operations and their corresponding functions
-operations = {
-    '+': operator.add,
-    '-': operator.sub,
-    '*': operator.mul,
-    '/': operator.truediv
-}
-
-def generate_random_number():
-    return float("%.3f" % random.uniform(min_value, max_value))
-
-def safe_division(numerator, denominator):
-    return numerator if denominator == 0 else numerator / denominator
-
-# Generate complex data
-data = []
-for _ in range(num_samples):
-    num1 = generate_random_number()
-    num2 = generate_random_number()
-    num3 = generate_random_number()
-    # Ensure num2 and num3 are not zero if they will be used as divisors
-    if num2 == 0.0:
-        num2 = generate_random_number()
-    if num3 == 0.0:
-        num3 = generate_random_number()
-
-    # Randomly choose two operations
-    operation1 = random.choice(list(operations.keys()))
-    operation2 = random.choice(list(operations.keys()))
-    
-    # Create a more complex expression
-    if random.choice([True, False]):
-        # With parentheses
-        expression = f"({num1} {operation1} {num2}) {operation2} {num3}"
-        if operation1 == '/':
-            intermediate_result = safe_division(num1, num2)
-        else:
-            intermediate_result = operations[operation1](num1, num2)
-        if operation2 == '/' and intermediate_result != 0:
-            result = safe_division(intermediate_result, num3)
-        else:
-            result = operations[operation2](intermediate_result, num3)
-    else:
-        # Without parentheses
-        expression = f"{num1} {operation1} {num2} {operation2} {num3}"
-        if operation1 == '/':
-            intermediate_result = safe_division(num1, num2)
-        else:
-            intermediate_result = operations[operation1](num1, num2)
-        if operation2 == '/':
-            result = safe_division(intermediate_result, num3)
-        else:
-            result = operations[operation2](intermediate_result, num3)
-
-    output = "%.4f" % result
-    data.append({'instruction': expression, 'output': output})
-
-# Create the dataset
-out_file = 'arithmetic-float-complex.json'
-with open(out_file, 'w') as f:
-    json.dump(data, f)