File size: 5,035 Bytes
cf5659c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
import json
import math
import os
from argparse import ArgumentParser
from os import listdir
from os.path import isfile
def get_args():
parser = ArgumentParser()
# --experiments tr3d-1B3-oscar-checkpoints,tr3e-1B3-c4-checkpoints,tr3m-1B3-pile-checkpoints
parser.add_argument('--experiment', type=str, required=True,
help='Experiment we want to download.')
parser.add_argument('--result-dir', type=str, required=True,
help='Result directory containing all results, and to store aggregated json results.')
parser.add_argument('--batch-size', type=int, default=512,
help='Experiment training batch size.')
parser.add_argument('--sequence_length', type=int, default=2048,
help='Experiment training sequence length.')
parser.add_argument('--rampup-batch-size', type=lambda s: tuple(int(item) for item in s.split(',')), default=(32, 32, 2_000_000),
help='Experiment training batch size rampup.')
return parser.parse_args()
def checkpoint_step_to_tokens(checkpoint_step, args) -> int:
def fn(checkpoint_step) -> int:
if not hasattr(checkpoint_step_to_tokens, "CACHE"):
checkpoint_step_to_tokens.CACHE = {}
BATCH_SIZE=args.batch_size
SEQUENCE_LENGTH=args.sequence_length
# Linear increase in terms of samples.
RAMPUP_BATCH_SIZE = args.rampup_batch_size
# Compute RAMPUP checkpoint_step
if not hasattr(checkpoint_step_to_tokens, "RAMPUP_OFFSET"):
initial_batch_size, increment_batch_size, sample_limit_for_rampup = RAMPUP_BATCH_SIZE
number_of_increments = (BATCH_SIZE - initial_batch_size) // increment_batch_size
assert (BATCH_SIZE - initial_batch_size) % increment_batch_size == 0
offset_step = 0
start_sample = 0
for incr in range(number_of_increments):
batch_size = initial_batch_size + incr * increment_batch_size
end_sample = int(math.ceil((incr + 1) * sample_limit_for_rampup / number_of_increments))
number_of_step_per_increment = int(math.ceil((end_sample - start_sample) / batch_size))
checkpoint_step_to_tokens.CACHE.update({
offset_step + i: (start_sample + i * batch_size) * SEQUENCE_LENGTH
for i in range(number_of_step_per_increment)
})
offset_step += number_of_step_per_increment
start_sample += number_of_step_per_increment * batch_size
checkpoint_step_to_tokens.CACHE[offset_step] = start_sample * SEQUENCE_LENGTH
checkpoint_step_to_tokens.RAMPUP_OFFSET = offset_step
if checkpoint_step in checkpoint_step_to_tokens.CACHE:
return checkpoint_step_to_tokens.CACHE[checkpoint_step]
number_steps_after_rampup = checkpoint_step - checkpoint_step_to_tokens.RAMPUP_OFFSET
assert number_steps_after_rampup >= 0
slope = BATCH_SIZE * SEQUENCE_LENGTH
checkpoint_step_to_tokens.CACHE[checkpoint_step] = \
checkpoint_step_to_tokens.CACHE[checkpoint_step_to_tokens.RAMPUP_OFFSET] + \
slope * number_steps_after_rampup
return checkpoint_step_to_tokens.CACHE[checkpoint_step]
return fn(checkpoint_step)
def main():
args = get_args()
result_dir = args.result_dir
experiment = args.experiment
results_file_per_checkpoint = [
file
for file in listdir(result_dir)
if isfile(os.path.join(result_dir, file)) and file.startswith(experiment)
]
checkpoint_steps = sorted([int(file.split("_")[-1].split(".json")[0]) for file in results_file_per_checkpoint])
absolute_paths = [f"{result_dir}/{experiment}_{checkpoint_step}.json" for checkpoint_step in checkpoint_steps]
# format = "{EXPERIMENT_NAME}_{CHECKPOINT_STEP}.json"
tokens = [checkpoint_step_to_tokens(checkpoint_step, args) for checkpoint_step in checkpoint_steps]
result_json = {}
for absolute_path in absolute_paths:
with open(absolute_path, 'r') as fi:
results = json.load(fi)["results"]
for task in results:
if task not in result_json:
result_json[task] = {}
for metric in results[task]:
if metric not in result_json[task]:
result_json[task][metric] = []
result_json[task][metric].append(results[task][metric])
# check
for task in result_json:
assert len(tokens) == len(checkpoint_steps)
for metric in result_json[task]:
assert len(result_json[task][metric]) == len(checkpoint_steps)
output_path = os.path.join(result_dir, f"{experiment}_agg.json")
print(f"Printing results to {output_path}")
with open(output_path, 'w') as fo:
json.dump({"tokens": tokens, "checkpoints": checkpoint_steps, "results": result_json}, fo, indent=2)
if __name__ == "__main__":
main()
|