Here is my project.

README.md

@@ -1,3 +1,59 @@
----
-license: mit
----
+---
+license: mit
+task_categories:
+- translation
+language:
+- en
+tags:
+- code
+pretty_name: Base64 encode version1
+size_categories:
+- 10K<n<100K
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: data/data.jsonl
+---
+
+# Dataset: Base64 encode version1
+
+This dataset is for improving base64 encoding capabilities.
+
+`GPT 4o` is great at base64 encoding.
+
+```
+user: 
+convert this hex data to base64:
+880567a1
+
+assistant:
+The base64 encoding of the hex data `880567a1` is `iAVnoQ==`.
+
+user:
+convert this json data representing a byte sequence to base64:
+[30,41,183]
+
+assistant:
+The base64 encoding of the JSON data `[30,41,183]` is `Him3`.
+```
+
+However `llama3` is terrible at base64 encoding.
+
+Short examples of what `data.jsonl` looks like:
+
+```text
+{"instruction": "Encode hex to Base64", "input": "ecfc2db9ba6049165b", "output": "7PwtubpgSRZb"}
+{"instruction": "change HEX to base64", "input": "60926e782008", "output": "YJJueCAI"}
+{"instruction": "Json to base64", "input": "[77,62,160,64,248,233,105,133,5,248,89,239]", "output": "TT6gQPjpaYUF+Fnv"}
+{"instruction": "Change Json to BASE64", "input": "[10,59,42,251,112,1]", "output": "Cjsq+3AB"}
+{"instruction": "Convert JSON to Base64", "input": "[236,201,129,100,238]", "output": "7MmBZO4="}
+```
+
+# Generate dataset
+
+```
+PROMPT> python generate_dataset.py
+```
+
+This creates the `data.jsonl` file.

generate_dataset.py

@@ -0,0 +1,104 @@
+from random_data import generate_random_byte_array
+import json
+import os
+import random
+import base64
+
+def base64_encode_byte_array(byte_array):
+    return base64.b64encode(byte_array).decode('utf-8')
+
+def generate_dataset_item(seed):
+    length = random.Random(seed + 1000).randint(0, 127)
+    byte_array = generate_random_byte_array(length=length, seed=seed + 1001)
+
+    input_formats = [
+        'hex', 
+        'json'
+    ]
+    input_format = random.Random(seed + 1002).choice(input_formats)
+
+    names_hex = [
+        'Hexadecimal',
+        'hexadecimal',
+        'hex',
+        'Hex',
+        'HEX',
+    ]
+    names_json = [
+        'Json',
+        'json',
+        'JSON',
+    ]
+
+    name_input = None
+    if input_format == 'hex':
+        name_input = random.Random(seed + 1003).choice(names_hex)
+    else:
+        if input_format == 'json':
+            name_input = random.Random(seed + 1004).choice(names_json)
+
+    name_outputs = [
+        'base64',
+        'Base64',
+        'BASE64',
+    ]
+    name_output = random.Random(seed + 1005).choice(name_outputs)
+
+    instructions = [
+        f'Encode {name_input} to {name_output}',
+        f'encode {name_input} to {name_output}',
+        f'convert {name_input} to {name_output}',
+        f'Convert {name_input} to {name_output}',
+        f'Transform {name_input} to {name_output}',
+        f'transform {name_input} to {name_output}',
+        f'Change {name_input} to {name_output}',
+        f'change {name_input} to {name_output}',
+        f'{name_input} to {name_output}',
+        f'{name_output} from {name_input}',
+    ]
+
+    instruction = random.Random(seed + 1006).choice(instructions)
+
+    output = base64_encode_byte_array(byte_array)
+
+    input = None
+    if input_format == 'hex':
+        input = byte_array.hex()
+    else:
+        if input_format == 'json':
+            input = json.dumps(list(byte_array), separators=(',', ':'))
+
+    dict = {
+        'instruction': instruction,
+        'input': input,
+        'output': output
+    }
+    return dict
+
+def generate_dataset(max_num_samples=1000, max_byte_size=1024*1024, seed_start=500000000):
+    dataset = []
+    dataset_byte_size = 0
+    for i in range(max_num_samples):
+        item = generate_dataset_item(seed_start + i)
+        bytes = len(json.dumps(item))
+        if dataset_byte_size + bytes > max_byte_size:
+            break
+        dataset_byte_size += bytes
+        dataset.append(item)
+    return dataset
+
+dataset = generate_dataset(
+    max_num_samples=50000,
+    max_byte_size=1024*1024*20,
+)
+
+# Save dataset to file
+filename = 'data.jsonl'
+with open(filename, 'w') as f:
+    for item in dataset:
+        f.write(json.dumps(item) + '\n')
+
+# Summary
+file_size = os.path.getsize(filename)
+print(f"Generated {len(dataset)} samples, saved to {filename}, file size: {file_size} bytes.")
+

random_data.py

@@ -0,0 +1,11 @@
+import random
+
+def generate_random_byte_array(length, seed):
+    random.seed(seed)
+    return bytearray(random.randint(0, 255) for _ in range(length))
+
+if __name__ == "__main__":
+    length = 10
+    seed = 42
+    byte_array = generate_random_byte_array(length, seed)
+    print(byte_array)

test_random_data.py

@@ -0,0 +1,21 @@
+import unittest
+from random_data import generate_random_byte_array
+
+class TestRandomData(unittest.TestCase):
+    def test_generate_random_byte_array_empty(self):
+        actual = generate_random_byte_array(length=0, seed=0)
+        expected = bytearray()
+        self.assertEqual(actual, expected)
+
+    def test_generate_random_byte_array_length1(self):
+        actual = generate_random_byte_array(length=1, seed=0)
+        expected = bytearray([0xc5])
+        self.assertEqual(actual, expected)
+
+    def test_generate_random_byte_array_length2(self):
+        actual = generate_random_byte_array(length=2, seed=0)
+        expected = bytearray([0xc5, 0xd7])
+        self.assertEqual(actual, expected)
+    
+if __name__ == '__main__':
+    unittest.main()