diff --git a/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260517/train8_ode_decode_support_len256_cpu_uniform_now/allcorrupt/summary.json b/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260517/train8_ode_decode_support_len256_cpu_uniform_now/allcorrupt/summary.json new file mode 100644 index 0000000000000000000000000000000000000000..0580006023ef7ea70db1a6adf01cced23a55cd2f --- /dev/null +++ b/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260517/train8_ode_decode_support_len256_cpu_uniform_now/allcorrupt/summary.json @@ -0,0 +1,3197 @@ +{ + "checkpoint": "runs/train8_n256_compactv969_3l_bs512_hard_ce_allcorrupt/latest.pt", + "data_dir": "/e2e-data/evad-tech-vla/wanghan58/data/small_benchmarks/langflow_2604_11748/openwebtext_lta_cached_chunks/gpt2_len256_train8_compact_overfit", + "max_len": 256, + "n_samples": 64, + "steps": 128, + "seed": 20314773, + "time_schedule": "uniform", + "time_logit_mean": -1.5, + "time_logit_std": 0.8, + "model_t_mode": "post", + "final_token_acc_mean": 0.33282470703125, + "final_token_acc_min": 0.0234375, + "final_token_acc_max": 0.6484375, + "final_exact_count": 0, + "final_best_ref_counts": [ + 7, + 9, + 5, + 14, + 3, + 9, + 10, + 7 + ], + "lock_stats": { + "final_token_acc_mean": 0.33282470703125, + "final_exact_count": 0, + "final_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 2, + 3, + 6, + 0, + 1, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 2, + 1, + 3, + 3, + 1, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 0, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 2 + ], + "wrong_count_per_sample": [ + 196, + 196, + 115, + 95, + 233, + 246, + 121, + 115, + 193, + 250, + 246, + 165, + 224, + 184, + 239, + 181, + 95, + 162, + 183, + 183, + 149, + 176, + 101, + 164, + 122, + 185, + 115, + 107, + 246, + 241, + 172, + 127, + 239, + 195, + 113, + 125, + 90, + 167, + 206, + 205, + 184, + 184, + 110, + 91, + 207, + 114, + 236, + 112, + 137, + 245, + 106, + 104, + 141, + 150, + 173, + 240, + 237, + 112, + 91, + 247, + 160, + 240, + 200, + 243 + ], + "wrong_state_lock_step": { + "n": 10931, + "min": 0.0, + "p25": 79.0, + "median": 118.0, + "p75": 127.0, + "max": 128.0, + "mean": 103.36181502149849 + }, + "wrong_endpoint_first_emit_step": { + "n": 10931, + "min": 1.0, + "p25": 18.5, + "median": 99.0, + "p75": 124.0, + "max": 128.0, + "mean": 77.59893879791419 + }, + "num_steps": 128 + }, + "snapshots": { + "1": { + "state_top_tokens": [ + { + "id": 615, + "old_text": " remained", + "count": 35, + "mass": 0.00213623046875 + }, + { + "id": 236, + "old_text": " New", + "count": 32, + "mass": 0.001953125 + }, + { + "id": 359, + "old_text": " York", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 390, + "old_text": " Ge", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 491, + "old_text": " etc", + "count": 29, + "mass": 0.00177001953125 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 1341, + "mass": 0.08184814453125 + }, + { + "id": 34, + "old_text": "\\n", + "count": 884, + "mass": 0.053955078125 + }, + { + "id": 5, + "old_text": ".", + "count": 881, + "mass": 0.05377197265625 + }, + { + "id": 40, + "old_text": " the", + "count": 648, + "mass": 0.03955078125 + }, + { + "id": 52, + "old_text": " to", + "count": 405, + "mass": 0.02471923828125 + } + ], + "state_best_acc": [ + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.01171875, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625 + ], + "endpoint_best_acc": [ + 0.07421875, + 0.13671875, + 0.31640625, + 0.46484375, + 0.265625, + 0.1796875, + 0.63671875, + 0.58984375, + 0.51953125, + 0.37890625, + 0.3984375, + 0.1640625, + 0.26171875, + 0.078125, + 0.171875, + 0.234375, + 0.26953125, + 0.359375, + 0.45703125, + 0.140625, + 0.19921875, + 0.22265625, + 0.27734375, + 0.22265625, + 0.125, + 0.3671875, + 0.46875, + 0.4140625, + 0.43359375, + 0.203125, + 0.28515625, + 0.2265625, + 0.16015625, + 0.265625, + 0.61328125, + 0.6328125, + 0.36328125, + 0.41796875, + 0.1640625, + 0.15234375, + 0.5078125, + 0.109375, + 0.07421875, + 0.62890625, + 0.36328125, + 0.44140625, + 0.1875, + 0.453125, + 0.0859375, + 0.09375, + 0.26953125, + 0.24609375, + 0.14453125, + 0.16015625, + 0.390625, + 0.2890625, + 0.109375, + 0.4296875, + 0.37890625, + 0.26171875, + 0.23828125, + 0.26171875, + 0.28125, + 0.33984375 + ], + "state_best_ref": [ + 1, + 2, + 5, + 5, + 0, + 7, + 3, + 7, + 2, + 1, + 1, + 0, + 1, + 7, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 1, + 0, + 6, + 3, + 1, + 5, + 4, + 4, + 0, + 3, + 1, + 6, + 1, + 0, + 3, + 3, + 0, + 3, + 2, + 0, + 2, + 3, + 0, + 1, + 0, + 0, + 1, + 3, + 3, + 6, + 0, + 1, + 7, + 0, + 7, + 0, + 2, + 1, + 0, + 5, + 6, + 2, + 1 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 6, + 0, + 3, + 6, + 0, + 5, + 4, + 1, + 5, + 6, + 6, + 7, + 5, + 6, + 1, + 1, + 6, + 1, + 5, + 1, + 4, + 1, + 6, + 5, + 4, + 7, + 3, + 3, + 2, + 1, + 6, + 3, + 5, + 0, + 6, + 2, + 1, + 4, + 2, + 5, + 6, + 6, + 4, + 6, + 3, + 4, + 6, + 0, + 4, + 6, + 7, + 2, + 7, + 6, + 5, + 2, + 3, + 4, + 5, + 4 + ] + }, + "2": { + "state_top_tokens": [ + { + "id": 615, + "old_text": " remained", + "count": 35, + "mass": 0.00213623046875 + }, + { + "id": 236, + "old_text": " New", + "count": 32, + "mass": 0.001953125 + }, + { + "id": 359, + "old_text": " York", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 390, + "old_text": " Ge", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 491, + "old_text": " etc", + "count": 29, + "mass": 0.00177001953125 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 1303, + "mass": 0.07952880859375 + }, + { + "id": 5, + "old_text": ".", + "count": 865, + "mass": 0.05279541015625 + }, + { + "id": 34, + "old_text": "\\n", + "count": 848, + "mass": 0.0517578125 + }, + { + "id": 40, + "old_text": " the", + "count": 637, + "mass": 0.03887939453125 + }, + { + "id": 52, + "old_text": " to", + "count": 418, + "mass": 0.0255126953125 + } + ], + "state_best_acc": [ + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.01171875, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625 + ], + "endpoint_best_acc": [ + 0.1015625, + 0.203125, + 0.3984375, + 0.51953125, + 0.3203125, + 0.1171875, + 0.640625, + 0.62109375, + 0.52734375, + 0.375, + 0.41796875, + 0.21875, + 0.203125, + 0.1015625, + 0.15234375, + 0.21484375, + 0.30859375, + 0.3671875, + 0.484375, + 0.1640625, + 0.1953125, + 0.25, + 0.29296875, + 0.17578125, + 0.15234375, + 0.41796875, + 0.53515625, + 0.41796875, + 0.4453125, + 0.203125, + 0.31640625, + 0.2421875, + 0.15625, + 0.29296875, + 0.640625, + 0.6328125, + 0.38671875, + 0.48828125, + 0.1328125, + 0.1875, + 0.5234375, + 0.09375, + 0.07421875, + 0.65234375, + 0.3515625, + 0.51953125, + 0.265625, + 0.4921875, + 0.078125, + 0.125, + 0.3359375, + 0.2109375, + 0.12890625, + 0.171875, + 0.42578125, + 0.28125, + 0.11328125, + 0.453125, + 0.4375, + 0.24609375, + 0.2578125, + 0.31640625, + 0.265625, + 0.42578125 + ], + "state_best_ref": [ + 1, + 2, + 5, + 5, + 0, + 7, + 3, + 7, + 2, + 1, + 1, + 0, + 1, + 7, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 1, + 0, + 6, + 3, + 1, + 5, + 4, + 4, + 0, + 3, + 1, + 6, + 1, + 0, + 3, + 3, + 0, + 3, + 2, + 0, + 2, + 3, + 0, + 1, + 0, + 0, + 1, + 3, + 3, + 6, + 0, + 1, + 7, + 0, + 7, + 0, + 2, + 1, + 0, + 5, + 6, + 2, + 1 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 6, + 0, + 3, + 6, + 0, + 5, + 4, + 1, + 5, + 4, + 6, + 7, + 5, + 6, + 1, + 1, + 6, + 1, + 5, + 1, + 4, + 1, + 6, + 5, + 4, + 7, + 3, + 3, + 2, + 1, + 6, + 3, + 5, + 0, + 6, + 2, + 1, + 6, + 2, + 5, + 6, + 6, + 4, + 6, + 3, + 0, + 6, + 0, + 4, + 6, + 7, + 2, + 7, + 6, + 5, + 2, + 3, + 4, + 5, + 4 + ] + }, + "4": { + "state_top_tokens": [ + { + "id": 615, + "old_text": " remained", + "count": 35, + "mass": 0.00213623046875 + }, + { + "id": 236, + "old_text": " New", + "count": 32, + "mass": 0.001953125 + }, + { + "id": 359, + "old_text": " York", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 390, + "old_text": " Ge", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 491, + "old_text": " etc", + "count": 29, + "mass": 0.00177001953125 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 1208, + "mass": 0.07373046875 + }, + { + "id": 5, + "old_text": ".", + "count": 855, + "mass": 0.05218505859375 + }, + { + "id": 34, + "old_text": "\\n", + "count": 782, + "mass": 0.0477294921875 + }, + { + "id": 40, + "old_text": " the", + "count": 646, + "mass": 0.0394287109375 + }, + { + "id": 52, + "old_text": " to", + "count": 381, + "mass": 0.02325439453125 + } + ], + "state_best_acc": [ + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.01171875, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625 + ], + "endpoint_best_acc": [ + 0.1484375, + 0.3046875, + 0.5078125, + 0.5859375, + 0.234375, + 0.18359375, + 0.66015625, + 0.67578125, + 0.5234375, + 0.33203125, + 0.45703125, + 0.328125, + 0.11328125, + 0.1015625, + 0.1015625, + 0.23046875, + 0.40234375, + 0.39453125, + 0.52734375, + 0.16015625, + 0.21875, + 0.328125, + 0.35546875, + 0.28515625, + 0.1796875, + 0.5625, + 0.63671875, + 0.453125, + 0.5, + 0.2265625, + 0.359375, + 0.2890625, + 0.1640625, + 0.30859375, + 0.66015625, + 0.66015625, + 0.484375, + 0.5859375, + 0.13671875, + 0.27734375, + 0.58984375, + 0.1484375, + 0.07421875, + 0.69140625, + 0.296875, + 0.6015625, + 0.45703125, + 0.5, + 0.12890625, + 0.1875, + 0.37890625, + 0.26171875, + 0.13671875, + 0.20703125, + 0.484375, + 0.24609375, + 0.1640625, + 0.49609375, + 0.5390625, + 0.1875, + 0.23046875, + 0.3984375, + 0.203125, + 0.53125 + ], + "state_best_ref": [ + 1, + 2, + 5, + 5, + 0, + 7, + 3, + 7, + 2, + 1, + 1, + 0, + 1, + 7, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 1, + 0, + 6, + 3, + 1, + 5, + 4, + 4, + 0, + 3, + 1, + 6, + 1, + 0, + 3, + 3, + 0, + 3, + 2, + 0, + 2, + 3, + 0, + 1, + 0, + 0, + 1, + 3, + 3, + 6, + 0, + 1, + 7, + 0, + 7, + 0, + 2, + 1, + 0, + 5, + 2, + 2, + 1 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 2, + 3, + 6, + 0, + 5, + 4, + 1, + 0, + 7, + 2, + 6, + 5, + 6, + 1, + 7, + 6, + 1, + 5, + 0, + 4, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 2, + 1, + 6, + 3, + 5, + 0, + 7, + 2, + 1, + 6, + 4, + 5, + 6, + 6, + 4, + 6, + 5, + 0, + 6, + 6, + 4, + 6, + 7, + 2, + 7, + 6, + 5, + 2, + 3, + 4, + 1, + 4 + ] + }, + "8": { + "state_top_tokens": [ + { + "id": 615, + "old_text": " remained", + "count": 35, + "mass": 0.00213623046875 + }, + { + "id": 236, + "old_text": " New", + "count": 32, + "mass": 0.001953125 + }, + { + "id": 359, + "old_text": " York", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 390, + "old_text": " Ge", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 491, + "old_text": " etc", + "count": 29, + "mass": 0.00177001953125 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 948, + "mass": 0.057861328125 + }, + { + "id": 5, + "old_text": ".", + "count": 682, + "mass": 0.0416259765625 + }, + { + "id": 40, + "old_text": " the", + "count": 607, + "mass": 0.03704833984375 + }, + { + "id": 34, + "old_text": "\\n", + "count": 593, + "mass": 0.03619384765625 + }, + { + "id": 52, + "old_text": " to", + "count": 296, + "mass": 0.01806640625 + } + ], + "state_best_acc": [ + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.01171875, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625 + ], + "endpoint_best_acc": [ + 0.38671875, + 0.39453125, + 0.69921875, + 0.62890625, + 0.6015625, + 0.328125, + 0.68359375, + 0.7265625, + 0.6171875, + 0.23828125, + 0.609375, + 0.50390625, + 0.14453125, + 0.23828125, + 0.078125, + 0.49609375, + 0.54296875, + 0.41015625, + 0.625, + 0.5, + 0.28125, + 0.6171875, + 0.41796875, + 0.51171875, + 0.05078125, + 0.76171875, + 0.7265625, + 0.48046875, + 0.50390625, + 0.5, + 0.296875, + 0.58203125, + 0.109375, + 0.12890625, + 0.62890625, + 0.69921875, + 0.7109375, + 0.5859375, + 0.140625, + 0.54296875, + 0.75390625, + 0.15234375, + 0.1953125, + 0.734375, + 0.45703125, + 0.6796875, + 0.71875, + 0.59765625, + 0.25390625, + 0.2109375, + 0.3515625, + 0.3125, + 0.09375, + 0.359375, + 0.56640625, + 0.125, + 0.23828125, + 0.62109375, + 0.69921875, + 0.05859375, + 0.578125, + 0.58984375, + 0.5, + 0.703125 + ], + "state_best_ref": [ + 1, + 2, + 5, + 5, + 0, + 7, + 3, + 7, + 2, + 1, + 1, + 0, + 1, + 7, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 1, + 0, + 6, + 3, + 1, + 5, + 4, + 4, + 0, + 3, + 1, + 6, + 1, + 0, + 3, + 3, + 0, + 3, + 2, + 0, + 2, + 3, + 0, + 1, + 0, + 0, + 1, + 3, + 3, + 6, + 0, + 1, + 7, + 0, + 7, + 0, + 2, + 1, + 0, + 5, + 2, + 2, + 1 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 4, + 3, + 6, + 0, + 5, + 4, + 1, + 2, + 7, + 2, + 7, + 5, + 6, + 1, + 7, + 6, + 1, + 5, + 0, + 4, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 0, + 1, + 6, + 3, + 5, + 0, + 7, + 2, + 1, + 3, + 5, + 5, + 7, + 6, + 4, + 6, + 5, + 0, + 6, + 6, + 3, + 6, + 7, + 2, + 7, + 6, + 5, + 2, + 0, + 4, + 1, + 4 + ] + }, + "16": { + "state_top_tokens": [ + { + "id": 615, + "old_text": " remained", + "count": 35, + "mass": 0.00213623046875 + }, + { + "id": 236, + "old_text": " New", + "count": 32, + "mass": 0.001953125 + }, + { + "id": 359, + "old_text": " York", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 390, + "old_text": " Ge", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 491, + "old_text": " etc", + "count": 29, + "mass": 0.00177001953125 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 673, + "mass": 0.04107666015625 + }, + { + "id": 40, + "old_text": " the", + "count": 523, + "mass": 0.03192138671875 + }, + { + "id": 5, + "old_text": ".", + "count": 500, + "mass": 0.030517578125 + }, + { + "id": 34, + "old_text": "\\n", + "count": 442, + "mass": 0.0269775390625 + }, + { + "id": 113, + "old_text": "�", + "count": 254, + "mass": 0.0155029296875 + } + ], + "state_best_acc": [ + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.01171875, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0, + 0.00390625, + 0.01171875, + 0.00390625, + 0.00390625, + 0.0, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.0, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625 + ], + "endpoint_best_acc": [ + 0.5234375, + 0.25390625, + 0.8046875, + 0.546875, + 0.62109375, + 0.60546875, + 0.66015625, + 0.74609375, + 0.60546875, + 0.0703125, + 0.75, + 0.72265625, + 0.296875, + 0.46484375, + 0.0703125, + 0.71484375, + 0.50390625, + 0.31640625, + 0.68359375, + 0.71875, + 0.41015625, + 0.79296875, + 0.46875, + 0.6875, + 0.0703125, + 0.76171875, + 0.7734375, + 0.40234375, + 0.54296875, + 0.51953125, + 0.34765625, + 0.75390625, + 0.48046875, + 0.09765625, + 0.50390625, + 0.6953125, + 0.76171875, + 0.671875, + 0.1171875, + 0.609375, + 0.765625, + 0.21875, + 0.60546875, + 0.70703125, + 0.18359375, + 0.67578125, + 0.73828125, + 0.6875, + 0.14453125, + 0.15234375, + 0.2578125, + 0.3125, + 0.234375, + 0.40625, + 0.62890625, + 0.1015625, + 0.359375, + 0.8046875, + 0.59375, + 0.015625, + 0.65625, + 0.703125, + 0.69140625, + 0.7578125 + ], + "state_best_ref": [ + 1, + 2, + 5, + 5, + 0, + 7, + 3, + 6, + 2, + 1, + 1, + 0, + 1, + 7, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 1, + 0, + 6, + 3, + 1, + 5, + 4, + 4, + 0, + 3, + 1, + 6, + 1, + 0, + 3, + 3, + 0, + 3, + 2, + 0, + 2, + 3, + 0, + 1, + 0, + 4, + 1, + 3, + 3, + 6, + 0, + 1, + 7, + 0, + 7, + 0, + 2, + 1, + 0, + 5, + 2, + 2, + 1 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 4, + 3, + 6, + 0, + 1, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 0, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 0, + 3, + 3, + 3, + 6, + 7, + 7, + 7, + 6, + 5, + 6, + 0, + 4, + 1, + 4 + ] + }, + "32": { + "state_top_tokens": [ + { + "id": 615, + "old_text": " remained", + "count": 35, + "mass": 0.00213623046875 + }, + { + "id": 3, + "old_text": ",", + "count": 35, + "mass": 0.00213623046875 + }, + { + "id": 236, + "old_text": " New", + "count": 32, + "mass": 0.001953125 + }, + { + "id": 390, + "old_text": " Ge", + "count": 31, + "mass": 0.00189208984375 + }, + { + "id": 359, + "old_text": " York", + "count": 30, + "mass": 0.0018310546875 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 847, + "mass": 0.05169677734375 + }, + { + "id": 40, + "old_text": " the", + "count": 591, + "mass": 0.03607177734375 + }, + { + "id": 5, + "old_text": ".", + "count": 552, + "mass": 0.03369140625 + }, + { + "id": 34, + "old_text": "\\n", + "count": 519, + "mass": 0.03167724609375 + }, + { + "id": 113, + "old_text": "�", + "count": 277, + "mass": 0.01690673828125 + } + ], + "state_best_acc": [ + 0.00390625, + 0.00390625, + 0.01171875, + 0.015625, + 0.015625, + 0.0078125, + 0.015625, + 0.02734375, + 0.00390625, + 0.01171875, + 0.00390625, + 0.01171875, + 0.00390625, + 0.01953125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0078125, + 0.00390625, + 0.03125, + 0.00390625, + 0.01171875, + 0.00390625, + 0.01953125, + 0.0234375, + 0.0078125, + 0.03515625, + 0.0078125, + 0.01171875, + 0.0078125, + 0.00390625, + 0.00390625, + 0.015625, + 0.01953125, + 0.0234375, + 0.0234375, + 0.00390625, + 0.01953125, + 0.03125, + 0.00390625, + 0.01953125, + 0.01953125, + 0.00390625, + 0.015625, + 0.01953125, + 0.0078125, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.0078125, + 0.00390625, + 0.0078125, + 0.00390625, + 0.00390625, + 0.00390625, + 0.02734375, + 0.0, + 0.01171875, + 0.015625, + 0.00390625, + 0.01953125 + ], + "endpoint_best_acc": [ + 0.6171875, + 0.421875, + 0.81640625, + 0.56640625, + 0.62890625, + 0.578125, + 0.7421875, + 0.76953125, + 0.47265625, + 0.046875, + 0.7421875, + 0.75390625, + 0.3359375, + 0.6875, + 0.0703125, + 0.7265625, + 0.546875, + 0.39453125, + 0.796875, + 0.73046875, + 0.41015625, + 0.74609375, + 0.46875, + 0.703125, + 0.12890625, + 0.7890625, + 0.796875, + 0.421875, + 0.73828125, + 0.5234375, + 0.4140625, + 0.75390625, + 0.48828125, + 0.18359375, + 0.58203125, + 0.68359375, + 0.765625, + 0.55078125, + 0.16015625, + 0.62109375, + 0.76171875, + 0.25390625, + 0.72265625, + 0.7265625, + 0.25390625, + 0.7265625, + 0.76171875, + 0.78515625, + 0.203125, + 0.0703125, + 0.51171875, + 0.51171875, + 0.4921875, + 0.33203125, + 0.71875, + 0.05859375, + 0.3671875, + 0.765625, + 0.6640625, + 0.015625, + 0.68359375, + 0.7734375, + 0.6875, + 0.73828125 + ], + "state_best_ref": [ + 1, + 2, + 6, + 5, + 0, + 7, + 3, + 6, + 0, + 3, + 1, + 1, + 0, + 7, + 0, + 3, + 3, + 3, + 1, + 7, + 6, + 1, + 0, + 0, + 3, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 6, + 1, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 2, + 3, + 5, + 1, + 6, + 4, + 6, + 3, + 3, + 3, + 2, + 1, + 6, + 7, + 7, + 0, + 2, + 5, + 0, + 0, + 4, + 1, + 4 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 4, + 3, + 6, + 0, + 1, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 0, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 4, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 4 + ] + }, + "64": { + "state_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 638, + "mass": 0.0389404296875 + }, + { + "id": 34, + "old_text": "\\n", + "count": 441, + "mass": 0.02691650390625 + }, + { + "id": 40, + "old_text": " the", + "count": 423, + "mass": 0.02581787109375 + }, + { + "id": 5, + "old_text": ".", + "count": 414, + "mass": 0.0252685546875 + }, + { + "id": 38, + "old_text": " a", + "count": 214, + "mass": 0.0130615234375 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 982, + "mass": 0.0599365234375 + }, + { + "id": 34, + "old_text": "\\n", + "count": 669, + "mass": 0.04083251953125 + }, + { + "id": 40, + "old_text": " the", + "count": 667, + "mass": 0.04071044921875 + }, + { + "id": 5, + "old_text": ".", + "count": 663, + "mass": 0.04046630859375 + }, + { + "id": 38, + "old_text": " a", + "count": 328, + "mass": 0.02001953125 + } + ], + "state_best_acc": [ + 0.50390625, + 0.33203125, + 0.67578125, + 0.484375, + 0.4296875, + 0.3828125, + 0.6171875, + 0.66015625, + 0.27734375, + 0.0234375, + 0.59375, + 0.58984375, + 0.22265625, + 0.47265625, + 0.04296875, + 0.578125, + 0.48046875, + 0.31640625, + 0.58203125, + 0.57421875, + 0.3203125, + 0.6015625, + 0.42578125, + 0.4765625, + 0.1171875, + 0.64453125, + 0.6484375, + 0.39453125, + 0.53125, + 0.2734375, + 0.296875, + 0.62109375, + 0.17578125, + 0.13671875, + 0.50390625, + 0.609375, + 0.625, + 0.38671875, + 0.109375, + 0.48046875, + 0.6484375, + 0.19921875, + 0.578125, + 0.62109375, + 0.18359375, + 0.5546875, + 0.625, + 0.6328125, + 0.16015625, + 0.03515625, + 0.43359375, + 0.4140625, + 0.359375, + 0.26953125, + 0.6015625, + 0.046875, + 0.09765625, + 0.61328125, + 0.55859375, + 0.015625, + 0.5234375, + 0.62890625, + 0.5, + 0.6015625 + ], + "endpoint_best_acc": [ + 0.62890625, + 0.4921875, + 0.78125, + 0.58203125, + 0.41796875, + 0.39453125, + 0.69921875, + 0.7734375, + 0.28125, + 0.02734375, + 0.6796875, + 0.6953125, + 0.29296875, + 0.59765625, + 0.08984375, + 0.671875, + 0.58984375, + 0.43359375, + 0.703125, + 0.68359375, + 0.5390625, + 0.67578125, + 0.5703125, + 0.49609375, + 0.28515625, + 0.74609375, + 0.7890625, + 0.55078125, + 0.58984375, + 0.296875, + 0.37109375, + 0.69140625, + 0.234375, + 0.25, + 0.72265625, + 0.70703125, + 0.75, + 0.38671875, + 0.22265625, + 0.5703125, + 0.72265625, + 0.3125, + 0.6875, + 0.7265625, + 0.28515625, + 0.72265625, + 0.6953125, + 0.76171875, + 0.35546875, + 0.09375, + 0.66015625, + 0.65625, + 0.57421875, + 0.4375, + 0.6953125, + 0.07421875, + 0.13671875, + 0.7421875, + 0.66796875, + 0.0234375, + 0.54296875, + 0.703125, + 0.625, + 0.6953125 + ], + "state_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 4, + 3, + 6, + 0, + 1, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 0, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 4, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 4 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 4, + 3, + 6, + 0, + 0, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 0, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 4, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 4 + ] + }, + "96": { + "state_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 1003, + "mass": 0.06121826171875 + }, + { + "id": 34, + "old_text": "\\n", + "count": 773, + "mass": 0.04718017578125 + }, + { + "id": 5, + "old_text": ".", + "count": 693, + "mass": 0.04229736328125 + }, + { + "id": 40, + "old_text": " the", + "count": 691, + "mass": 0.04217529296875 + }, + { + "id": 38, + "old_text": " a", + "count": 352, + "mass": 0.021484375 + } + ], + "endpoint_top_tokens": [ + { + "id": 3, + "old_text": ",", + "count": 1058, + "mass": 0.0645751953125 + }, + { + "id": 34, + "old_text": "\\n", + "count": 932, + "mass": 0.056884765625 + }, + { + "id": 40, + "old_text": " the", + "count": 723, + "mass": 0.04412841796875 + }, + { + "id": 5, + "old_text": ".", + "count": 684, + "mass": 0.041748046875 + }, + { + "id": 38, + "old_text": " a", + "count": 379, + "mass": 0.02313232421875 + } + ], + "state_best_acc": [ + 0.61328125, + 0.46875, + 0.77734375, + 0.59375, + 0.41015625, + 0.3125, + 0.6875, + 0.76171875, + 0.32421875, + 0.04296875, + 0.62109375, + 0.68359375, + 0.26953125, + 0.578125, + 0.0859375, + 0.6640625, + 0.59765625, + 0.41796875, + 0.61328125, + 0.67578125, + 0.5390625, + 0.59765625, + 0.59375, + 0.46875, + 0.3046875, + 0.73046875, + 0.7734375, + 0.55078125, + 0.5234375, + 0.29296875, + 0.359375, + 0.66015625, + 0.2265625, + 0.2421875, + 0.70703125, + 0.69140625, + 0.7421875, + 0.41015625, + 0.2265625, + 0.484375, + 0.64453125, + 0.30859375, + 0.69140625, + 0.72265625, + 0.28515625, + 0.70703125, + 0.66796875, + 0.734375, + 0.3828125, + 0.08203125, + 0.66796875, + 0.6640625, + 0.5625, + 0.4296875, + 0.68359375, + 0.06640625, + 0.11328125, + 0.7265625, + 0.69140625, + 0.02734375, + 0.50390625, + 0.640625, + 0.60546875, + 0.671875 + ], + "endpoint_best_acc": [ + 0.59375, + 0.4453125, + 0.68359375, + 0.6015625, + 0.35546875, + 0.12890625, + 0.65234375, + 0.6640625, + 0.30078125, + 0.03515625, + 0.43359375, + 0.5703125, + 0.21484375, + 0.5390625, + 0.06640625, + 0.62109375, + 0.578125, + 0.41796875, + 0.35546875, + 0.61328125, + 0.5078125, + 0.45703125, + 0.61328125, + 0.40625, + 0.33984375, + 0.61328125, + 0.69921875, + 0.5703125, + 0.390625, + 0.24609375, + 0.34765625, + 0.63671875, + 0.15625, + 0.2578125, + 0.6484375, + 0.65234375, + 0.71875, + 0.359375, + 0.22265625, + 0.34375, + 0.390625, + 0.3125, + 0.67578125, + 0.69140625, + 0.30859375, + 0.609375, + 0.48046875, + 0.6875, + 0.421875, + 0.078125, + 0.65234375, + 0.66796875, + 0.56640625, + 0.45703125, + 0.64453125, + 0.0703125, + 0.06640625, + 0.65625, + 0.6796875, + 0.03125, + 0.4296875, + 0.48046875, + 0.5546875, + 0.51171875 + ], + "state_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 4, + 3, + 6, + 0, + 2, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 0, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 4, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 4 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 4, + 3, + 6, + 0, + 2, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 4, + 0, + 3, + 3, + 0, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 4, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 4 + ] + }, + "128": { + "state_top_tokens": [ + { + "id": 34, + "old_text": "\\n", + "count": 1230, + "mass": 0.0750732421875 + }, + { + "id": 3, + "old_text": ",", + "count": 1132, + "mass": 0.069091796875 + }, + { + "id": 40, + "old_text": " the", + "count": 840, + "mass": 0.05126953125 + }, + { + "id": 5, + "old_text": ".", + "count": 710, + "mass": 0.0433349609375 + }, + { + "id": 38, + "old_text": " a", + "count": 543, + "mass": 0.03314208984375 + } + ], + "endpoint_top_tokens": [ + { + "id": 34, + "old_text": "\\n", + "count": 1230, + "mass": 0.0750732421875 + }, + { + "id": 3, + "old_text": ",", + "count": 1132, + "mass": 0.069091796875 + }, + { + "id": 40, + "old_text": " the", + "count": 840, + "mass": 0.05126953125 + }, + { + "id": 5, + "old_text": ".", + "count": 710, + "mass": 0.0433349609375 + }, + { + "id": 38, + "old_text": " a", + "count": 543, + "mass": 0.03314208984375 + } + ], + "state_best_acc": [ + 0.234375, + 0.234375, + 0.55078125, + 0.62890625, + 0.08984375, + 0.0390625, + 0.52734375, + 0.55078125, + 0.24609375, + 0.0234375, + 0.0390625, + 0.35546875, + 0.125, + 0.28125, + 0.06640625, + 0.29296875, + 0.62890625, + 0.3671875, + 0.28515625, + 0.28515625, + 0.41796875, + 0.3125, + 0.60546875, + 0.359375, + 0.5234375, + 0.27734375, + 0.55078125, + 0.58203125, + 0.0390625, + 0.05859375, + 0.328125, + 0.50390625, + 0.06640625, + 0.23828125, + 0.55859375, + 0.51171875, + 0.6484375, + 0.34765625, + 0.1953125, + 0.19921875, + 0.28125, + 0.28125, + 0.5703125, + 0.64453125, + 0.19140625, + 0.5546875, + 0.078125, + 0.5625, + 0.46484375, + 0.04296875, + 0.5859375, + 0.59375, + 0.44921875, + 0.4140625, + 0.32421875, + 0.0625, + 0.07421875, + 0.5625, + 0.64453125, + 0.03515625, + 0.375, + 0.0625, + 0.21875, + 0.05078125 + ], + "endpoint_best_acc": [ + 0.234375, + 0.234375, + 0.55078125, + 0.62890625, + 0.08984375, + 0.0390625, + 0.52734375, + 0.55078125, + 0.24609375, + 0.0234375, + 0.0390625, + 0.35546875, + 0.125, + 0.28125, + 0.06640625, + 0.29296875, + 0.62890625, + 0.3671875, + 0.28515625, + 0.28515625, + 0.41796875, + 0.3125, + 0.60546875, + 0.359375, + 0.5234375, + 0.27734375, + 0.55078125, + 0.58203125, + 0.0390625, + 0.05859375, + 0.328125, + 0.50390625, + 0.06640625, + 0.23828125, + 0.55859375, + 0.51171875, + 0.6484375, + 0.34765625, + 0.1953125, + 0.19921875, + 0.28125, + 0.28125, + 0.5703125, + 0.64453125, + 0.19140625, + 0.5546875, + 0.078125, + 0.5625, + 0.46484375, + 0.04296875, + 0.5859375, + 0.59375, + 0.44921875, + 0.4140625, + 0.32421875, + 0.0625, + 0.07421875, + 0.5625, + 0.64453125, + 0.03515625, + 0.375, + 0.0625, + 0.21875, + 0.05078125 + ], + "state_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 2, + 3, + 6, + 0, + 1, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 2, + 1, + 3, + 3, + 1, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 0, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 2 + ], + "endpoint_best_ref": [ + 7, + 7, + 6, + 5, + 0, + 2, + 3, + 6, + 0, + 1, + 4, + 1, + 2, + 7, + 3, + 7, + 5, + 3, + 1, + 7, + 6, + 1, + 5, + 0, + 5, + 1, + 6, + 5, + 2, + 1, + 3, + 3, + 1, + 3, + 6, + 3, + 5, + 0, + 3, + 2, + 1, + 3, + 3, + 5, + 7, + 6, + 4, + 6, + 5, + 0, + 3, + 3, + 3, + 6, + 7, + 3, + 0, + 6, + 5, + 6, + 0, + 4, + 1, + 2 + ] + } + }, + "last_step": { + "step": 128, + "progress": 0.9921875, + "next_progress": 1.0, + "dt": 0.0078125, + "gamma": 1.0, + "temperature": 1.0, + "endpoint_alpha": 1.0, + "state_acc_before_mean": 0.34881591796875, + "state_acc_after_mean": 0.33282470703125, + "endpoint_acc_mean": 0.33282470703125, + "state_exact_after": 0, + "endpoint_exact": 0, + "state_pgold_best_mean": 0.33046483993530273, + "endpoint_pgold_best_mean": 0.3132457137107849, + "state_entropy_mean": 0.6723271012306213, + "endpoint_entropy_mean": 0.672324538230896, + "state_maxprob_mean": 0.7957823872566223, + "endpoint_maxprob_mean": 0.7957860827445984, + "oracle_clean_acc_mean": 0.603515625, + "oracle_clean_pgold_mean": 0.5734644532203674, + "state_best_ref_mode": 3, + "endpoint_best_ref_mode": 3, + "state_best_ref_counts": [ + 7, + 9, + 5, + 14, + 3, + 9, + 10, + 7 + ], + "endpoint_best_ref_counts": [ + 7, + 9, + 5, + 14, + 3, + 9, + 10, + 7 + ] + } +} \ No newline at end of file diff --git a/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_1gpu_rollout_return_base_diag_20260514_002906.log b/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_1gpu_rollout_return_base_diag_20260514_002906.log new file mode 100644 index 0000000000000000000000000000000000000000..69617c81ed4fae84a6e9b0c9953ac73ee354292d --- /dev/null +++ b/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_1gpu_rollout_return_base_diag_20260514_002906.log @@ -0,0 +1,103 @@ +{ + "device": "cuda:0", + "rank": 0, + "world_size": 1, + "samples": "owt_cached_chunks:8734897", + "vocab_size": 50257, + "tokenizer_vocab_size": 50257, + "save_dir": "runs/lta_owt_gpt2cached_len1024_1gpu_rollout_return_base_diag_20260514_002906", + "batch_size": 32, + "grad_accum": 1, + "effective_batch_size": 32, + "global_batch_size": 32, + "lr_schedule": "constant_warmup", + "optimizer": "muon", + "warmup_steps": 2000, + "min_lr": 0.0, + "weight_decay": 0.0, + "adamw_param_groups": "nanogpt", + "adam_beta1": 0.9, + "adam_beta2": 0.95, + "adam_eps": 1e-08, + "muon_momentum": 0.95, + "muon_ns_steps": 5, + "muon_update_scale": 1.0, + "ema_decay": 0.0, + "ema_start_step": 0, + "model_type": "ddit", + "dual_t": true, + "corrupt_t_mode": "same", + "corrupt_min_t": 0.0, + "corrupt_max_t": 1.0, + "prefix_block_prob": 0.0, + "prefix_block_len": 128, + "mask_ratio_floor_schedule": "none", + "dirichlet_endpoint_mode": "categorical_dual_t", + "dirichlet_semantic_t_mode": "same", + "dirichlet_semantic_t_value": 0.0, + "dirichlet_semantic_t_curve": "linear", + "dirichlet_semantic_t_power": 1.0, + "endpoint_sequence_random_prob_alpha": 0.0, + "categorical_wrong_from_full_vocab": true, + "categorical_wrong_from_batch_valid_tokens": false, + "mask_mixture_original_prob": 0.0, + "mask_mixture_lowk_prob": 0.0, + "mask_mixture_lowcorrupt_prob": 0.0, + "mask_mixture_block_prob": 0.0, + "mask_mixture_all_prob": 0.0, + "mask_mixture_lowk_clean_tokens": "1,2,4,8,16,32,64", + "mask_mixture_lowcorrupt_tokens": "1,2,4,8,16,32,64", + "mask_mixture_block_tokens": "64,128", + "simplex_bridge_sampler": "dirichlet", + "logistic_normal_sigma_min": 0.18, + "logistic_normal_sigma_max": 2.2, + "logistic_normal_tau_min": 0.65, + "logistic_normal_tau_max": 1.15, + "torch_compile": false, + "compile_mode": "max-autotune", + "state_format": "prob", + "target_loss": "hard_ce", + "meanflow_weight": 0.0, + "rollout_train_prob": 0.5, + "rollout_train_steps": 1, + "rollout_train_infer_steps": 64, + "rollout_train_temp": 1.45, + "rollout_train_max_gamma": 1.0, + "rollout_train_corrupt_only": true, + "rollout_train_samplewise": true, + "rollout_train_compute_always": false, + "bridge_noise_init": "logistic_normal", + "noise_sigma": -1.0, + "allow_tf32": true, + "activation_checkpointing": false, + "activation_checkpoint_interval": 1, + "activation_checkpoint_scope": "block", + "ddp_static_graph": false, + "ddp_gradient_as_bucket_view": true, + "blocking_data_transfer": false, + "dataloader_prefetch_factor": 4, + "full_train_stats": false, + "record_pad_truncate": false, + "record_add_eos": false, + "record_add_special_tokens": false, + "record_pad_token": "pad", + "record_shuffle_buffer": 10000, + "wrap": true, + "wrap_mode": "stream", + "wrap_record_buffer_size": 200, + "owt_cached_chunks": true, + "owt_chunk_cache_dir": "/e2e-data/evad-tech-vla/wanghan58/data/small_benchmarks/langflow_2604_11748/openwebtext_lta_cached_chunks/gpt2_len1024_train_minus_100k", + "owt_chunk_cache_rebuild": false, + "owt_chunk_cache_write_batch": 4096, + "owt_exact_repeat_per_chunk": 0, + "online_chunk_shuffle": false, + "online_chunk_shuffle_buffer": 10000, + "openwebtext_split": "train_minus_100k", + "detokenizer": "auto", + "resolved_detokenizer": null, + "num_workers": 4, + "latest_every": 0, + "resume_path": "" +} +step=20 micro_steps=20 elapsed=20.2s lr=2.100000e-05 loss=10.8125 loss_recon=10.8125 loss_meanflow=0.0000 mean_model_t=0.4886 mean_corrupt_t=0.4886 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5078 acc_all=0.0005 acc_corrupt=0.0003 corrupt_frac=0.4716 loss_all=10.8125 loss_corrupt=10.8125 acc_corrupt_t_0p0_0p2=0.0037 corrupt_frac_t_0p0_0p2=0.0353 acc_corrupt_t_0p2_0p4=0.0000 corrupt_frac_t_0p2_0p4=0.3025 acc_corrupt_t_0p4_0p6=0.0000 corrupt_frac_t_0p4_0p6=0.1542 acc_corrupt_t_0p6_0p8=0.0004 corrupt_frac_t_0p6_0p8=0.3077 acc_corrupt_t_0p8_1p0=0.0000 corrupt_frac_t_0p8_1p0=0.2003 wrong_frac=0.4271 init_acc_corrupt=0.5455 init_gold_top10=0.5717 init_gold_top100=0.5815 rollout_applied_pos_frac=0.5593 init_acc_rollout_applied=0.5406 init_acc_rollout_kept=0.5517 logit_acc_rollout_applied=0.0000 logit_acc_rollout_kept=0.0006 +step=40 micro_steps=40 elapsed=22.1s lr=4.100000e-05 loss=10.8125 loss_recon=10.8125 loss_meanflow=0.0000 mean_model_t=0.5122 mean_corrupt_t=0.5122 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5016 acc_all=0.0003 acc_corrupt=0.0004 corrupt_frac=0.4598 loss_all=10.8125 loss_corrupt=10.8125 acc_corrupt_t_0p0_0p2=0.0007 corrupt_frac_t_0p0_0p2=0.0958 acc_corrupt_t_0p2_0p4=0.0008 corrupt_frac_t_0p2_0p4=0.2545 acc_corrupt_t_0p4_0p6=0.0005 corrupt_frac_t_0p4_0p6=0.2818 acc_corrupt_t_0p6_0p8=0.0000 corrupt_frac_t_0p6_0p8=0.2028 acc_corrupt_t_0p8_1p0=0.0000 corrupt_frac_t_0p8_1p0=0.1651 wrong_frac=0.4979 init_acc_corrupt=0.4701 init_gold_top10=0.4988 init_gold_top100=0.5169 rollout_applied_pos_frac=0.5595 init_acc_rollout_applied=0.4179 init_acc_rollout_kept=0.5363 logit_acc_rollout_applied=0.0007 logit_acc_rollout_kept=0.0000 diff --git a/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_selfcond_p05_autocastfix_smoke4gpu_20260514_005005.log b/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_selfcond_p05_autocastfix_smoke4gpu_20260514_005005.log new file mode 100644 index 0000000000000000000000000000000000000000..1ba8768d38ceaa3455f22a25aa941401f47cb6ab --- /dev/null +++ b/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_selfcond_p05_autocastfix_smoke4gpu_20260514_005005.log @@ -0,0 +1,104 @@ +NCCL version 2.25.1+cuda12.8 +{ + "device": "cuda:0", + "rank": 0, + "world_size": 4, + "samples": "owt_cached_chunks:8734897", + "vocab_size": 50257, + "tokenizer_vocab_size": 50257, + "save_dir": "runs/lta_owt_gpt2cached_len1024_selfcond_p05_autocastfix_smoke4gpu_20260514_005005", + "batch_size": 32, + "grad_accum": 4, + "effective_batch_size": 512, + "global_batch_size": 512, + "lr_schedule": "constant_warmup", + "optimizer": "muon", + "warmup_steps": 2000, + "min_lr": 0.0, + "weight_decay": 0.0, + "adamw_param_groups": "nanogpt", + "adam_beta1": 0.9, + "adam_beta2": 0.95, + "adam_eps": 1e-08, + "muon_momentum": 0.95, + "muon_ns_steps": 5, + "muon_update_scale": 1.0, + "ema_decay": 0.0, + "ema_start_step": 0, + "model_type": "ddit", + "dual_t": true, + "corrupt_t_mode": "same", + "corrupt_min_t": 0.0, + "corrupt_max_t": 1.0, + "prefix_block_prob": 0.0, + "prefix_block_len": 128, + "mask_ratio_floor_schedule": "none", + "dirichlet_endpoint_mode": "categorical_dual_t", + "dirichlet_semantic_t_mode": "same", + "dirichlet_semantic_t_value": 0.0, + "dirichlet_semantic_t_curve": "linear", + "dirichlet_semantic_t_power": 1.0, + "endpoint_sequence_random_prob_alpha": 0.0, + "categorical_wrong_from_full_vocab": true, + "categorical_wrong_from_batch_valid_tokens": false, + "mask_mixture_original_prob": 0.0, + "mask_mixture_lowk_prob": 0.0, + "mask_mixture_lowcorrupt_prob": 0.0, + "mask_mixture_block_prob": 0.0, + "mask_mixture_all_prob": 0.0, + "mask_mixture_lowk_clean_tokens": "1,2,4,8,16,32,64", + "mask_mixture_lowcorrupt_tokens": "1,2,4,8,16,32,64", + "mask_mixture_block_tokens": "64,128", + "simplex_bridge_sampler": "dirichlet", + "logistic_normal_sigma_min": 0.18, + "logistic_normal_sigma_max": 2.2, + "logistic_normal_tau_min": 0.65, + "logistic_normal_tau_max": 1.15, + "torch_compile": false, + "compile_mode": "max-autotune", + "state_format": "prob", + "target_loss": "hard_ce", + "meanflow_weight": 0.0, + "rollout_train_prob": 0.5, + "rollout_train_steps": 1, + "rollout_train_infer_steps": 64, + "rollout_train_temp": 1.45, + "rollout_train_max_gamma": 1.0, + "rollout_train_corrupt_only": true, + "rollout_train_samplewise": true, + "rollout_train_compute_always": false, + "bridge_noise_init": "logistic_normal", + "noise_sigma": -1.0, + "allow_tf32": true, + "activation_checkpointing": false, + "activation_checkpoint_interval": 1, + "activation_checkpoint_scope": "block", + "ddp_static_graph": false, + "ddp_gradient_as_bucket_view": true, + "blocking_data_transfer": false, + "dataloader_prefetch_factor": 4, + "full_train_stats": false, + "record_pad_truncate": false, + "record_add_eos": false, + "record_add_special_tokens": false, + "record_pad_token": "pad", + "record_shuffle_buffer": 10000, + "wrap": true, + "wrap_mode": "stream", + "wrap_record_buffer_size": 200, + "owt_cached_chunks": true, + "owt_chunk_cache_dir": "/e2e-data/evad-tech-vla/wanghan58/data/small_benchmarks/langflow_2604_11748/openwebtext_lta_cached_chunks/gpt2_len1024_train_minus_100k", + "owt_chunk_cache_rebuild": false, + "owt_chunk_cache_write_batch": 4096, + "owt_exact_repeat_per_chunk": 0, + "online_chunk_shuffle": false, + "online_chunk_shuffle_buffer": 10000, + "openwebtext_split": "train_minus_100k", + "detokenizer": "auto", + "resolved_detokenizer": null, + "num_workers": 4, + "latest_every": 0, + "resume_path": "" +} +step=20 micro_steps=80 elapsed=85.9s lr=2.100000e-05 loss=10.8125 loss_recon=10.8125 loss_meanflow=0.0000 mean_model_t=0.4997 mean_corrupt_t=0.4997 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5125 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.0017 out_g_norm=1.0682 acc_all=0.5844 acc_corrupt=0.4340 corrupt_frac=0.5791 loss_all=10.8125 loss_corrupt=10.8125 acc_corrupt_t_0p0_0p2=0.0566 corrupt_frac_t_0p0_0p2=0.2347 acc_corrupt_t_0p2_0p4=0.2340 corrupt_frac_t_0p2_0p4=0.1446 acc_corrupt_t_0p4_0p6=0.4344 corrupt_frac_t_0p4_0p6=0.0960 acc_corrupt_t_0p6_0p8=0.5764 corrupt_frac_t_0p6_0p8=0.0845 acc_corrupt_t_0p8_1p0=0.6734 corrupt_frac_t_0p8_1p0=0.4403 wrong_frac=0.4264 init_acc_corrupt=0.5383 init_gold_top10=0.5672 init_gold_top100=0.6079 rollout_applied_pos_frac=0.5383 init_acc_rollout_applied=0.6241 init_acc_rollout_kept=0.4383 logit_acc_rollout_applied=0.5028 logit_acc_rollout_kept=0.3537 +step=40 micro_steps=160 elapsed=100.6s lr=4.100000e-05 loss=10.8125 loss_recon=10.8125 loss_meanflow=0.0000 mean_model_t=0.4828 mean_corrupt_t=0.4828 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5297 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.0121 out_g_norm=1.0545 acc_all=0.5412 acc_corrupt=0.3598 corrupt_frac=0.5686 loss_all=10.8125 loss_corrupt=10.8125 acc_corrupt_t_0p0_0p2=0.0256 corrupt_frac_t_0p0_0p2=0.2223 acc_corrupt_t_0p2_0p4=0.2657 corrupt_frac_t_0p2_0p4=0.2560 acc_corrupt_t_0p4_0p6=0.3865 corrupt_frac_t_0p4_0p6=0.1561 acc_corrupt_t_0p6_0p8=0.5197 corrupt_frac_t_0p6_0p8=0.1894 acc_corrupt_t_0p8_1p0=0.7223 corrupt_frac_t_0p8_1p0=0.1763 wrong_frac=0.5301 init_acc_corrupt=0.4423 init_gold_top10=0.4647 init_gold_top100=0.5096 rollout_applied_pos_frac=0.6069 init_acc_rollout_applied=0.4848 init_acc_rollout_kept=0.3766 logit_acc_rollout_applied=0.4024 logit_acc_rollout_kept=0.2940 diff --git a/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_selfcond_p05_rollout1_autocastfix_c1024_ddit768x12_muon_ema_gbs512_4gpu_50k_20260514_005426.log b/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_selfcond_p05_rollout1_autocastfix_c1024_ddit768x12_muon_ema_gbs512_4gpu_50k_20260514_005426.log new file mode 100644 index 0000000000000000000000000000000000000000..ad343b9b0559c61273505b137694399e86925657 --- /dev/null +++ b/LTA_openwebtext_dualt/logs/selfcond_4gpu/lta_owt_gpt2cached_len1024_selfcond_p05_rollout1_autocastfix_c1024_ddit768x12_muon_ema_gbs512_4gpu_50k_20260514_005426.log @@ -0,0 +1,315 @@ +NCCL version 2.25.1+cuda12.8 +{ + "device": "cuda:0", + "rank": 0, + "world_size": 4, + "samples": "owt_cached_chunks:8734897", + "vocab_size": 50257, + "tokenizer_vocab_size": 50257, + "save_dir": "runs/lta_owt_gpt2cached_len1024_selfcond_p05_rollout1_autocastfix_c1024_ddit768x12_muon_ema_gbs512_4gpu_50k_20260514_005426", + "batch_size": 32, + "grad_accum": 4, + "effective_batch_size": 512, + "global_batch_size": 512, + "lr_schedule": "constant_warmup", + "optimizer": "muon", + "warmup_steps": 2000, + "min_lr": 0.0, + "weight_decay": 0.0, + "adamw_param_groups": "nanogpt", + "adam_beta1": 0.9, + "adam_beta2": 0.95, + "adam_eps": 1e-08, + "muon_momentum": 0.95, + "muon_ns_steps": 5, + "muon_update_scale": 1.0, + "ema_decay": 0.9999, + "ema_start_step": 0, + "model_type": "ddit", + "dual_t": true, + "corrupt_t_mode": "same", + "corrupt_min_t": 0.0, + "corrupt_max_t": 1.0, + "prefix_block_prob": 0.0, + "prefix_block_len": 128, + "mask_ratio_floor_schedule": "none", + "dirichlet_endpoint_mode": "categorical_dual_t", + "dirichlet_semantic_t_mode": "same", + "dirichlet_semantic_t_value": 0.0, + "dirichlet_semantic_t_curve": "linear", + "dirichlet_semantic_t_power": 1.0, + "endpoint_sequence_random_prob_alpha": 0.0, + "categorical_wrong_from_full_vocab": true, + "categorical_wrong_from_batch_valid_tokens": false, + "mask_mixture_original_prob": 0.0, + "mask_mixture_lowk_prob": 0.0, + "mask_mixture_lowcorrupt_prob": 0.0, + "mask_mixture_block_prob": 0.0, + "mask_mixture_all_prob": 0.0, + "mask_mixture_lowk_clean_tokens": "1,2,4,8,16,32,64", + "mask_mixture_lowcorrupt_tokens": "1,2,4,8,16,32,64", + "mask_mixture_block_tokens": "64,128", + "simplex_bridge_sampler": "dirichlet", + "logistic_normal_sigma_min": 0.18, + "logistic_normal_sigma_max": 2.2, + "logistic_normal_tau_min": 0.65, + "logistic_normal_tau_max": 1.15, + "torch_compile": false, + "compile_mode": "max-autotune", + "state_format": "prob", + "target_loss": "hard_ce", + "meanflow_weight": 0.0, + "rollout_train_prob": 0.5, + "rollout_train_steps": 1, + "rollout_train_infer_steps": 64, + "rollout_train_temp": 1.45, + "rollout_train_max_gamma": 1.0, + "rollout_train_corrupt_only": true, + "rollout_train_samplewise": true, + "rollout_train_compute_always": false, + "bridge_noise_init": "logistic_normal", + "noise_sigma": -1.0, + "allow_tf32": true, + "activation_checkpointing": false, + "activation_checkpoint_interval": 1, + "activation_checkpoint_scope": "block", + "ddp_static_graph": false, + "ddp_gradient_as_bucket_view": true, + "blocking_data_transfer": false, + "dataloader_prefetch_factor": 4, + "full_train_stats": false, + "record_pad_truncate": false, + "record_add_eos": false, + "record_add_special_tokens": false, + "record_pad_token": "pad", + "record_shuffle_buffer": 10000, + "wrap": true, + "wrap_mode": "stream", + "wrap_record_buffer_size": 200, + "owt_cached_chunks": true, + "owt_chunk_cache_dir": "/e2e-data/evad-tech-vla/wanghan58/data/small_benchmarks/langflow_2604_11748/openwebtext_lta_cached_chunks/gpt2_len1024_train_minus_100k", + "owt_chunk_cache_rebuild": false, + "owt_chunk_cache_write_batch": 4096, + "owt_exact_repeat_per_chunk": 0, + "online_chunk_shuffle": false, + "online_chunk_shuffle_buffer": 10000, + "openwebtext_split": "train_minus_100k", + "detokenizer": "auto", + "resolved_detokenizer": null, + "num_workers": 4, + "latest_every": 500, + "resume_path": "" +} +step=50 micro_steps=200 elapsed=253.4s lr=5.100000e-05 loss=10.8125 loss_recon=10.8125 loss_meanflow=0.0000 mean_model_t=0.4971 mean_corrupt_t=0.4971 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5156 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.0108 out_g_norm=1.0679 acc_all=0.5484 acc_corrupt=0.3117 corrupt_frac=0.4875 loss_all=10.8125 loss_corrupt=10.8125 acc_corrupt_t_0p0_0p2=0.0351 corrupt_frac_t_0p0_0p2=0.3316 acc_corrupt_t_0p2_0p4=0.2559 corrupt_frac_t_0p2_0p4=0.1869 acc_corrupt_t_0p4_0p6=0.3949 corrupt_frac_t_0p4_0p6=0.2254 acc_corrupt_t_0p6_0p8=0.6036 corrupt_frac_t_0p6_0p8=0.1202 acc_corrupt_t_0p8_1p0=0.6667 corrupt_frac_t_0p8_1p0=0.1360 wrong_frac=0.5788 init_acc_corrupt=0.3875 init_gold_top10=0.4119 init_gold_top100=0.4542 rollout_applied_pos_frac=0.3793 init_acc_rollout_applied=0.4869 init_acc_rollout_kept=0.3268 logit_acc_rollout_applied=0.3667 logit_acc_rollout_kept=0.2780 +step=100 micro_steps=400 elapsed=259.8s lr=1.010000e-04 loss=10.7951 loss_recon=10.7951 loss_meanflow=0.0000 mean_model_t=0.4984 mean_corrupt_t=0.4984 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5094 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.0747 out_g_norm=1.2127 acc_all=0.5368 acc_corrupt=0.3947 corrupt_frac=0.6203 loss_all=10.7597 loss_corrupt=10.7757 acc_corrupt_t_0p0_0p2=0.0439 corrupt_frac_t_0p0_0p2=0.1837 acc_corrupt_t_0p2_0p4=0.1662 corrupt_frac_t_0p2_0p4=0.1439 acc_corrupt_t_0p4_0p6=0.3830 corrupt_frac_t_0p4_0p6=0.1662 acc_corrupt_t_0p6_0p8=0.5264 corrupt_frac_t_0p6_0p8=0.2179 acc_corrupt_t_0p8_1p0=0.6394 corrupt_frac_t_0p8_1p0=0.2883 wrong_frac=0.4610 init_acc_corrupt=0.5059 init_gold_top10=0.5296 init_gold_top100=0.5732 rollout_applied_pos_frac=0.5360 init_acc_rollout_applied=0.5406 init_acc_rollout_kept=0.4658 logit_acc_rollout_applied=0.3924 logit_acc_rollout_kept=0.3973 +step=150 micro_steps=600 elapsed=260.9s lr=1.510000e-04 loss=10.7545 loss_recon=10.7545 loss_meanflow=0.0000 mean_model_t=0.4879 mean_corrupt_t=0.4879 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5038 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.1978 out_g_norm=1.3348 acc_all=0.5785 acc_corrupt=0.3699 corrupt_frac=0.4725 loss_all=10.6676 loss_corrupt=10.7205 acc_corrupt_t_0p0_0p2=0.0702 corrupt_frac_t_0p0_0p2=0.2144 acc_corrupt_t_0p2_0p4=0.2447 corrupt_frac_t_0p2_0p4=0.1571 acc_corrupt_t_0p4_0p6=0.3960 corrupt_frac_t_0p4_0p6=0.2348 acc_corrupt_t_0p6_0p8=0.5360 corrupt_frac_t_0p6_0p8=0.3242 acc_corrupt_t_0p8_1p0=0.7147 corrupt_frac_t_0p8_1p0=0.0695 wrong_frac=0.4944 init_acc_corrupt=0.4757 init_gold_top10=0.4995 init_gold_top100=0.5510 rollout_applied_pos_frac=0.4836 init_acc_rollout_applied=0.4225 init_acc_rollout_kept=0.5255 logit_acc_rollout_applied=0.3250 logit_acc_rollout_kept=0.4120 +step=200 micro_steps=800 elapsed=261.3s lr=2.010000e-04 loss=10.6791 loss_recon=10.6791 loss_meanflow=0.0000 mean_model_t=0.5079 mean_corrupt_t=0.5079 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5194 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.3759 out_g_norm=1.4685 acc_all=0.5050 acc_corrupt=0.3012 corrupt_frac=0.5182 loss_all=10.5612 loss_corrupt=10.6541 acc_corrupt_t_0p0_0p2=0.0261 corrupt_frac_t_0p0_0p2=0.0721 acc_corrupt_t_0p2_0p4=0.1731 corrupt_frac_t_0p2_0p4=0.4032 acc_corrupt_t_0p4_0p6=0.3352 corrupt_frac_t_0p4_0p6=0.3124 acc_corrupt_t_0p6_0p8=0.5794 corrupt_frac_t_0p6_0p8=0.0816 acc_corrupt_t_0p8_1p0=0.5932 corrupt_frac_t_0p8_1p0=0.1307 wrong_frac=0.5490 init_acc_corrupt=0.4043 init_gold_top10=0.4458 init_gold_top100=0.5024 rollout_applied_pos_frac=0.5930 init_acc_rollout_applied=0.4698 init_acc_rollout_kept=0.3089 logit_acc_rollout_applied=0.3461 logit_acc_rollout_kept=0.2359 +step=250 micro_steps=1000 elapsed=262.5s lr=2.510000e-04 loss=10.5739 loss_recon=10.5739 loss_meanflow=0.0000 mean_model_t=0.4981 mean_corrupt_t=0.4981 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4856 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.6069 out_g_norm=1.5818 acc_all=0.5513 acc_corrupt=0.3286 corrupt_frac=0.4510 loss_all=10.3523 loss_corrupt=10.5171 acc_corrupt_t_0p0_0p2=0.0522 corrupt_frac_t_0p0_0p2=0.3226 acc_corrupt_t_0p2_0p4=0.1589 corrupt_frac_t_0p2_0p4=0.0886 acc_corrupt_t_0p4_0p6=0.3309 corrupt_frac_t_0p4_0p6=0.2173 acc_corrupt_t_0p6_0p8=0.5622 corrupt_frac_t_0p6_0p8=0.0816 acc_corrupt_t_0p8_1p0=0.6205 corrupt_frac_t_0p8_1p0=0.2899 wrong_frac=0.5295 init_acc_corrupt=0.4366 init_gold_top10=0.4625 init_gold_top100=0.5310 rollout_applied_pos_frac=0.5047 init_acc_rollout_applied=0.5699 init_acc_rollout_kept=0.3007 logit_acc_rollout_applied=0.4163 logit_acc_rollout_kept=0.2393 +step=300 micro_steps=1200 elapsed=262.5s lr=3.010000e-04 loss=10.4328 loss_recon=10.4328 loss_meanflow=0.0000 mean_model_t=0.5028 mean_corrupt_t=0.5028 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4994 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=0.8890 out_g_norm=1.7098 acc_all=0.4796 acc_corrupt=0.2946 corrupt_frac=0.5448 loss_all=10.1850 loss_corrupt=10.3880 acc_corrupt_t_0p0_0p2=0.0538 corrupt_frac_t_0p0_0p2=0.1748 acc_corrupt_t_0p2_0p4=0.1269 corrupt_frac_t_0p2_0p4=0.3117 acc_corrupt_t_0p4_0p6=0.3755 corrupt_frac_t_0p4_0p6=0.1800 acc_corrupt_t_0p6_0p8=0.5136 corrupt_frac_t_0p6_0p8=0.2919 acc_corrupt_t_0p8_1p0=0.6752 corrupt_frac_t_0p8_1p0=0.0416 wrong_frac=0.5407 init_acc_corrupt=0.4085 init_gold_top10=0.4522 init_gold_top100=0.5125 rollout_applied_pos_frac=0.4724 init_acc_rollout_applied=0.5295 init_acc_rollout_kept=0.3001 logit_acc_rollout_applied=0.3735 logit_acc_rollout_kept=0.2239 +step=350 micro_steps=1400 elapsed=263.1s lr=3.510000e-04 loss=10.2638 loss_recon=10.2638 loss_meanflow=0.0000 mean_model_t=0.4928 mean_corrupt_t=0.4928 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5212 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=1.2182 out_g_norm=1.8708 acc_all=0.4782 acc_corrupt=0.3198 corrupt_frac=0.5546 loss_all=9.8996 loss_corrupt=10.1576 acc_corrupt_t_0p0_0p2=0.0793 corrupt_frac_t_0p0_0p2=0.2269 acc_corrupt_t_0p2_0p4=0.1578 corrupt_frac_t_0p2_0p4=0.1618 acc_corrupt_t_0p4_0p6=0.3474 corrupt_frac_t_0p4_0p6=0.2427 acc_corrupt_t_0p6_0p8=0.4070 corrupt_frac_t_0p6_0p8=0.1770 acc_corrupt_t_0p8_1p0=0.6258 corrupt_frac_t_0p8_1p0=0.1916 wrong_frac=0.5003 init_acc_corrupt=0.4607 init_gold_top10=0.4924 init_gold_top100=0.5593 rollout_applied_pos_frac=0.5217 init_acc_rollout_applied=0.4605 init_acc_rollout_kept=0.4609 logit_acc_rollout_applied=0.3277 logit_acc_rollout_kept=0.3111 +step=400 micro_steps=1600 elapsed=263.1s lr=4.010000e-04 loss=10.0393 loss_recon=10.0393 loss_meanflow=0.0000 mean_model_t=0.5004 mean_corrupt_t=0.5004 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=1.5904 out_g_norm=2.0763 acc_all=0.4528 acc_corrupt=0.2749 corrupt_frac=0.5280 loss_all=9.6246 loss_corrupt=10.0068 acc_corrupt_t_0p0_0p2=0.0468 corrupt_frac_t_0p0_0p2=0.3629 acc_corrupt_t_0p2_0p4=0.1899 corrupt_frac_t_0p2_0p4=0.1725 acc_corrupt_t_0p4_0p6=0.3198 corrupt_frac_t_0p4_0p6=0.1511 acc_corrupt_t_0p6_0p8=0.5558 corrupt_frac_t_0p6_0p8=0.0694 acc_corrupt_t_0p8_1p0=0.5663 corrupt_frac_t_0p8_1p0=0.2441 wrong_frac=0.5681 init_acc_corrupt=0.3933 init_gold_top10=0.4232 init_gold_top100=0.5203 rollout_applied_pos_frac=0.4284 init_acc_rollout_applied=0.4239 init_acc_rollout_kept=0.3704 logit_acc_rollout_applied=0.2836 logit_acc_rollout_kept=0.2684 +step=450 micro_steps=1800 elapsed=263.3s lr=4.510000e-04 loss=9.7831 loss_recon=9.7831 loss_meanflow=0.0000 mean_model_t=0.4910 mean_corrupt_t=0.4910 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4975 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=2.0015 out_g_norm=2.3182 acc_all=0.3975 acc_corrupt=0.2465 corrupt_frac=0.5821 loss_all=9.3935 loss_corrupt=9.8149 acc_corrupt_t_0p0_0p2=0.0479 corrupt_frac_t_0p0_0p2=0.2134 acc_corrupt_t_0p2_0p4=0.1662 corrupt_frac_t_0p2_0p4=0.1937 acc_corrupt_t_0p4_0p6=0.3126 corrupt_frac_t_0p4_0p6=0.3411 acc_corrupt_t_0p6_0p8=0.4148 corrupt_frac_t_0p6_0p8=0.1019 acc_corrupt_t_0p8_1p0=0.3680 corrupt_frac_t_0p8_1p0=0.1499 wrong_frac=0.5515 init_acc_corrupt=0.3912 init_gold_top10=0.4264 init_gold_top100=0.5021 rollout_applied_pos_frac=0.5629 init_acc_rollout_applied=0.3864 init_acc_rollout_kept=0.3975 logit_acc_rollout_applied=0.2527 logit_acc_rollout_kept=0.2385 +step=500 micro_steps=2000 elapsed=263.1s lr=5.010000e-04 loss=9.4762 loss_recon=9.4762 loss_meanflow=0.0000 mean_model_t=0.4924 mean_corrupt_t=0.4924 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5000 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=2.4545 out_g_norm=2.5496 acc_all=0.4904 acc_corrupt=0.3367 corrupt_frac=0.5148 loss_all=8.7060 loss_corrupt=9.2456 acc_corrupt_t_0p0_0p2=0.0731 corrupt_frac_t_0p0_0p2=0.1745 acc_corrupt_t_0p2_0p4=0.1755 corrupt_frac_t_0p2_0p4=0.2874 acc_corrupt_t_0p4_0p6=0.3442 corrupt_frac_t_0p4_0p6=0.1324 acc_corrupt_t_0p6_0p8=0.4275 corrupt_frac_t_0p6_0p8=0.1308 acc_corrupt_t_0p8_1p0=0.6257 corrupt_frac_t_0p8_1p0=0.2749 wrong_frac=0.4858 init_acc_corrupt=0.4647 init_gold_top10=0.5094 init_gold_top100=0.5926 rollout_applied_pos_frac=0.5539 init_acc_rollout_applied=0.4504 init_acc_rollout_kept=0.4823 logit_acc_rollout_applied=0.3288 logit_acc_rollout_kept=0.3465 +step=550 micro_steps=2200 elapsed=265.2s lr=5.510000e-04 loss=9.0552 loss_recon=9.0552 loss_meanflow=0.0000 mean_model_t=0.4960 mean_corrupt_t=0.4960 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4756 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=2.9567 out_g_norm=2.7518 acc_all=0.4931 acc_corrupt=0.2898 corrupt_frac=0.4567 loss_all=8.1917 loss_corrupt=9.0611 acc_corrupt_t_0p0_0p2=0.0629 corrupt_frac_t_0p0_0p2=0.3678 acc_corrupt_t_0p2_0p4=0.2109 corrupt_frac_t_0p2_0p4=0.1039 acc_corrupt_t_0p4_0p6=0.3747 corrupt_frac_t_0p4_0p6=0.1787 acc_corrupt_t_0p6_0p8=0.4664 corrupt_frac_t_0p6_0p8=0.2195 acc_corrupt_t_0p8_1p0=0.5796 corrupt_frac_t_0p8_1p0=0.1302 wrong_frac=0.5716 init_acc_corrupt=0.3819 init_gold_top10=0.4177 init_gold_top100=0.5178 rollout_applied_pos_frac=0.3879 init_acc_rollout_applied=0.4056 init_acc_rollout_kept=0.3669 logit_acc_rollout_applied=0.3147 logit_acc_rollout_kept=0.2740 +step=600 micro_steps=2400 elapsed=263.6s lr=6.010000e-04 loss=8.6293 loss_recon=8.6293 loss_meanflow=0.0000 mean_model_t=0.5019 mean_corrupt_t=0.5019 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5069 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=3.5138 out_g_norm=2.9487 acc_all=0.4679 acc_corrupt=0.3195 corrupt_frac=0.5985 loss_all=7.7169 loss_corrupt=8.5174 acc_corrupt_t_0p0_0p2=0.0582 corrupt_frac_t_0p0_0p2=0.3092 acc_corrupt_t_0p2_0p4=0.1486 corrupt_frac_t_0p2_0p4=0.0772 acc_corrupt_t_0p4_0p6=0.3865 corrupt_frac_t_0p4_0p6=0.1954 acc_corrupt_t_0p6_0p8=0.5109 corrupt_frac_t_0p6_0p8=0.2152 acc_corrupt_t_0p8_1p0=0.5151 corrupt_frac_t_0p8_1p0=0.2030 wrong_frac=0.5052 init_acc_corrupt=0.4479 init_gold_top10=0.4786 init_gold_top100=0.5518 rollout_applied_pos_frac=0.4736 init_acc_rollout_applied=0.5405 init_acc_rollout_kept=0.3645 logit_acc_rollout_applied=0.3500 logit_acc_rollout_kept=0.2921 +step=650 micro_steps=2600 elapsed=263.0s lr=6.510000e-04 loss=8.0753 loss_recon=8.0753 loss_meanflow=0.0000 mean_model_t=0.5019 mean_corrupt_t=0.5019 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=4.1277 out_g_norm=3.0882 acc_all=0.5502 acc_corrupt=0.4244 corrupt_frac=0.5399 loss_all=6.5054 loss_corrupt=7.3556 acc_corrupt_t_0p0_0p2=0.0751 corrupt_frac_t_0p0_0p2=0.2039 acc_corrupt_t_0p2_0p4=0.2433 corrupt_frac_t_0p2_0p4=0.1336 acc_corrupt_t_0p4_0p6=0.3960 corrupt_frac_t_0p4_0p6=0.1392 acc_corrupt_t_0p6_0p8=0.5544 corrupt_frac_t_0p6_0p8=0.1294 acc_corrupt_t_0p8_1p0=0.6338 corrupt_frac_t_0p8_1p0=0.3940 wrong_frac=0.4131 init_acc_corrupt=0.5559 init_gold_top10=0.5804 init_gold_top100=0.6560 rollout_applied_pos_frac=0.5658 init_acc_rollout_applied=0.5860 init_acc_rollout_kept=0.5166 logit_acc_rollout_applied=0.4461 logit_acc_rollout_kept=0.3960 +step=700 micro_steps=2800 elapsed=262.3s lr=7.010000e-04 loss=7.4948 loss_recon=7.4948 loss_meanflow=0.0000 mean_model_t=0.4975 mean_corrupt_t=0.4975 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4944 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=4.7911 out_g_norm=3.0373 acc_all=0.5352 acc_corrupt=0.3948 corrupt_frac=0.4865 loss_all=5.9372 loss_corrupt=6.9720 acc_corrupt_t_0p0_0p2=0.0635 corrupt_frac_t_0p0_0p2=0.2083 acc_corrupt_t_0p2_0p4=0.1892 corrupt_frac_t_0p2_0p4=0.1714 acc_corrupt_t_0p4_0p6=0.3895 corrupt_frac_t_0p4_0p6=0.1459 acc_corrupt_t_0p6_0p8=0.5515 corrupt_frac_t_0p6_0p8=0.1547 acc_corrupt_t_0p8_1p0=0.6475 corrupt_frac_t_0p8_1p0=0.3196 wrong_frac=0.4376 init_acc_corrupt=0.5122 init_gold_top10=0.5400 init_gold_top100=0.6225 rollout_applied_pos_frac=0.5153 init_acc_rollout_applied=0.5253 init_acc_rollout_kept=0.4983 logit_acc_rollout_applied=0.4196 logit_acc_rollout_kept=0.3684 +step=750 micro_steps=3000 elapsed=261.7s lr=7.510000e-04 loss=6.9963 loss_recon=6.9963 loss_meanflow=0.0000 mean_model_t=0.5011 mean_corrupt_t=0.5011 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5169 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=5.4735 out_g_norm=2.5082 acc_all=0.5484 acc_corrupt=0.3952 corrupt_frac=0.4818 loss_all=5.2815 loss_corrupt=6.5337 acc_corrupt_t_0p0_0p2=0.0633 corrupt_frac_t_0p0_0p2=0.1992 acc_corrupt_t_0p2_0p4=0.2049 corrupt_frac_t_0p2_0p4=0.1425 acc_corrupt_t_0p4_0p6=0.4296 corrupt_frac_t_0p4_0p6=0.2896 acc_corrupt_t_0p6_0p8=0.5292 corrupt_frac_t_0p6_0p8=0.0889 acc_corrupt_t_0p8_1p0=0.6505 corrupt_frac_t_0p8_1p0=0.2797 wrong_frac=0.4647 init_acc_corrupt=0.5060 init_gold_top10=0.5292 init_gold_top100=0.6122 rollout_applied_pos_frac=0.5884 init_acc_rollout_applied=0.5114 init_acc_rollout_kept=0.4982 logit_acc_rollout_applied=0.3977 logit_acc_rollout_kept=0.3917 +step=800 micro_steps=3200 elapsed=261.4s lr=8.010000e-04 loss=6.6825 loss_recon=6.6825 loss_meanflow=0.0000 mean_model_t=0.4931 mean_corrupt_t=0.4931 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5194 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=6.1796 out_g_norm=2.0179 acc_all=0.5341 acc_corrupt=0.3796 corrupt_frac=0.5099 loss_all=5.0964 loss_corrupt=6.4085 acc_corrupt_t_0p0_0p2=0.0903 corrupt_frac_t_0p0_0p2=0.2087 acc_corrupt_t_0p2_0p4=0.2248 corrupt_frac_t_0p2_0p4=0.2106 acc_corrupt_t_0p4_0p6=0.3815 corrupt_frac_t_0p4_0p6=0.1856 acc_corrupt_t_0p6_0p8=0.5374 corrupt_frac_t_0p6_0p8=0.1584 acc_corrupt_t_0p8_1p0=0.6651 corrupt_frac_t_0p8_1p0=0.2368 wrong_frac=0.4954 init_acc_corrupt=0.4647 init_gold_top10=0.5007 init_gold_top100=0.5688 rollout_applied_pos_frac=0.4122 init_acc_rollout_applied=0.4585 init_acc_rollout_kept=0.4690 logit_acc_rollout_applied=0.3770 logit_acc_rollout_kept=0.3813 +step=850 micro_steps=3400 elapsed=261.0s lr=8.510000e-04 loss=6.3877 loss_recon=6.3877 loss_meanflow=0.0000 mean_model_t=0.4917 mean_corrupt_t=0.4917 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5038 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=6.8980 out_g_norm=1.7563 acc_all=0.5209 acc_corrupt=0.3714 corrupt_frac=0.5646 loss_all=5.0025 loss_corrupt=6.2160 acc_corrupt_t_0p0_0p2=0.0796 corrupt_frac_t_0p0_0p2=0.0741 acc_corrupt_t_0p2_0p4=0.2338 corrupt_frac_t_0p2_0p4=0.3426 acc_corrupt_t_0p4_0p6=0.3428 corrupt_frac_t_0p4_0p6=0.2220 acc_corrupt_t_0p6_0p8=0.5645 corrupt_frac_t_0p6_0p8=0.2295 acc_corrupt_t_0p8_1p0=0.6049 corrupt_frac_t_0p8_1p0=0.1319 wrong_frac=0.4889 init_acc_corrupt=0.4539 init_gold_top10=0.4948 init_gold_top100=0.5880 rollout_applied_pos_frac=0.6631 init_acc_rollout_applied=0.4860 init_acc_rollout_kept=0.3908 logit_acc_rollout_applied=0.4011 logit_acc_rollout_kept=0.3130 +step=900 micro_steps=3600 elapsed=260.6s lr=9.010000e-04 loss=6.1087 loss_recon=6.1087 loss_meanflow=0.0000 mean_model_t=0.5022 mean_corrupt_t=0.5022 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5006 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=7.5754 out_g_norm=1.5028 acc_all=0.5023 acc_corrupt=0.3506 corrupt_frac=0.5987 loss_all=4.9305 loss_corrupt=6.1532 acc_corrupt_t_0p0_0p2=0.0779 corrupt_frac_t_0p0_0p2=0.3089 acc_corrupt_t_0p2_0p4=0.2726 corrupt_frac_t_0p2_0p4=0.1539 acc_corrupt_t_0p4_0p6=0.3992 corrupt_frac_t_0p4_0p6=0.1977 acc_corrupt_t_0p6_0p8=0.5394 corrupt_frac_t_0p6_0p8=0.1902 acc_corrupt_t_0p8_1p0=0.6907 corrupt_frac_t_0p8_1p0=0.1493 wrong_frac=0.5517 init_acc_corrupt=0.4101 init_gold_top10=0.4401 init_gold_top100=0.5393 rollout_applied_pos_frac=0.4923 init_acc_rollout_applied=0.4177 init_acc_rollout_kept=0.4028 logit_acc_rollout_applied=0.3538 logit_acc_rollout_kept=0.3476 +step=950 micro_steps=3800 elapsed=260.5s lr=9.510000e-04 loss=5.7782 loss_recon=5.7782 loss_meanflow=0.0000 mean_model_t=0.5036 mean_corrupt_t=0.5036 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5012 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=8.2610 out_g_norm=1.1869 acc_all=0.4852 acc_corrupt=0.3460 corrupt_frac=0.5851 loss_all=5.0061 loss_corrupt=6.1092 acc_corrupt_t_0p0_0p2=0.0699 corrupt_frac_t_0p0_0p2=0.3156 acc_corrupt_t_0p2_0p4=0.1717 corrupt_frac_t_0p2_0p4=0.1410 acc_corrupt_t_0p4_0p6=0.4018 corrupt_frac_t_0p4_0p6=0.1312 acc_corrupt_t_0p6_0p8=0.5410 corrupt_frac_t_0p6_0p8=0.2694 acc_corrupt_t_0p8_1p0=0.7095 corrupt_frac_t_0p8_1p0=0.1427 wrong_frac=0.5577 init_acc_corrupt=0.4024 init_gold_top10=0.4360 init_gold_top100=0.5468 rollout_applied_pos_frac=0.3298 init_acc_rollout_applied=0.3174 init_acc_rollout_kept=0.4442 logit_acc_rollout_applied=0.2921 logit_acc_rollout_kept=0.3726 +step=1000 micro_steps=4000 elapsed=260.6s lr=1.001000e-03 loss=5.6132 loss_recon=5.6132 loss_meanflow=0.0000 mean_model_t=0.4915 mean_corrupt_t=0.4915 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4931 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=9.0138 out_g_norm=0.9293 acc_all=0.5669 acc_corrupt=0.3927 corrupt_frac=0.5385 loss_all=4.0951 loss_corrupt=5.5214 acc_corrupt_t_0p0_0p2=0.0866 corrupt_frac_t_0p0_0p2=0.0877 acc_corrupt_t_0p2_0p4=0.2241 corrupt_frac_t_0p2_0p4=0.3469 acc_corrupt_t_0p4_0p6=0.4213 corrupt_frac_t_0p4_0p6=0.2543 acc_corrupt_t_0p6_0p8=0.6037 corrupt_frac_t_0p6_0p8=0.1635 acc_corrupt_t_0p8_1p0=0.6879 corrupt_frac_t_0p8_1p0=0.1476 wrong_frac=0.5209 init_acc_corrupt=0.4327 init_gold_top10=0.4764 init_gold_top100=0.5584 rollout_applied_pos_frac=0.3795 init_acc_rollout_applied=0.4730 init_acc_rollout_kept=0.4081 logit_acc_rollout_applied=0.4318 logit_acc_rollout_kept=0.3688 +step=1050 micro_steps=4200 elapsed=265.8s lr=1.051000e-03 loss=5.3216 loss_recon=5.3216 loss_meanflow=0.0000 mean_model_t=0.5077 mean_corrupt_t=0.5077 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4881 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=9.8308 out_g_norm=0.7293 acc_all=0.5484 acc_corrupt=0.3577 corrupt_frac=0.5062 loss_all=4.1652 loss_corrupt=5.6984 acc_corrupt_t_0p0_0p2=0.0663 corrupt_frac_t_0p0_0p2=0.3081 acc_corrupt_t_0p2_0p4=0.2508 corrupt_frac_t_0p2_0p4=0.1096 acc_corrupt_t_0p4_0p6=0.4121 corrupt_frac_t_0p4_0p6=0.1581 acc_corrupt_t_0p6_0p8=0.5393 corrupt_frac_t_0p6_0p8=0.3533 acc_corrupt_t_0p8_1p0=0.7619 corrupt_frac_t_0p8_1p0=0.0709 wrong_frac=0.5618 init_acc_corrupt=0.4046 init_gold_top10=0.4345 init_gold_top100=0.5575 rollout_applied_pos_frac=0.4940 init_acc_rollout_applied=0.3826 init_acc_rollout_kept=0.4260 logit_acc_rollout_applied=0.3402 logit_acc_rollout_kept=0.3747 +step=1100 micro_steps=4400 elapsed=264.9s lr=1.101000e-03 loss=5.1860 loss_recon=5.1860 loss_meanflow=0.0000 mean_model_t=0.4977 mean_corrupt_t=0.4977 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4975 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=10.6927 out_g_norm=0.6152 acc_all=0.6475 acc_corrupt=0.5067 corrupt_frac=0.4897 loss_all=3.2749 loss_corrupt=4.4339 acc_corrupt_t_0p0_0p2=0.0950 corrupt_frac_t_0p0_0p2=0.0944 acc_corrupt_t_0p2_0p4=0.3004 corrupt_frac_t_0p2_0p4=0.1317 acc_corrupt_t_0p4_0p6=0.4383 corrupt_frac_t_0p4_0p6=0.2787 acc_corrupt_t_0p6_0p8=0.5697 corrupt_frac_t_0p6_0p8=0.1747 acc_corrupt_t_0p8_1p0=0.7379 corrupt_frac_t_0p8_1p0=0.3205 wrong_frac=0.3885 init_acc_corrupt=0.5935 init_gold_top10=0.6033 init_gold_top100=0.6621 rollout_applied_pos_frac=0.3349 init_acc_rollout_applied=0.5473 init_acc_rollout_kept=0.6168 logit_acc_rollout_applied=0.4962 logit_acc_rollout_kept=0.5120 +step=1150 micro_steps=4600 elapsed=407.3s lr=1.151000e-03 loss=5.0232 loss_recon=5.0232 loss_meanflow=0.0000 mean_model_t=0.4954 mean_corrupt_t=0.4954 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4769 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=11.5660 out_g_norm=0.5157 acc_all=0.5808 acc_corrupt=0.4245 corrupt_frac=0.5784 loss_all=3.7579 loss_corrupt=4.9954 acc_corrupt_t_0p0_0p2=0.0803 corrupt_frac_t_0p0_0p2=0.2141 acc_corrupt_t_0p2_0p4=0.2719 corrupt_frac_t_0p2_0p4=0.1735 acc_corrupt_t_0p4_0p6=0.4481 corrupt_frac_t_0p4_0p6=0.2269 acc_corrupt_t_0p6_0p8=0.6451 corrupt_frac_t_0p6_0p8=0.2597 acc_corrupt_t_0p8_1p0=0.7227 corrupt_frac_t_0p8_1p0=0.1258 wrong_frac=0.5049 init_acc_corrupt=0.4578 init_gold_top10=0.4903 init_gold_top100=0.6113 rollout_applied_pos_frac=0.5430 init_acc_rollout_applied=0.3658 init_acc_rollout_kept=0.5671 logit_acc_rollout_applied=0.3604 logit_acc_rollout_kept=0.5008 +step=1200 micro_steps=4800 elapsed=277.9s lr=1.201000e-03 loss=4.8031 loss_recon=4.8031 loss_meanflow=0.0000 mean_model_t=0.5040 mean_corrupt_t=0.5040 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5025 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=12.4088 out_g_norm=0.4735 acc_all=0.6473 acc_corrupt=0.4666 corrupt_frac=0.4637 loss_all=3.0947 loss_corrupt=4.4656 acc_corrupt_t_0p0_0p2=0.0990 corrupt_frac_t_0p0_0p2=0.2540 acc_corrupt_t_0p2_0p4=0.2958 corrupt_frac_t_0p2_0p4=0.1123 acc_corrupt_t_0p4_0p6=0.4551 corrupt_frac_t_0p4_0p6=0.1537 acc_corrupt_t_0p6_0p8=0.6439 corrupt_frac_t_0p6_0p8=0.1937 acc_corrupt_t_0p8_1p0=0.7462 corrupt_frac_t_0p8_1p0=0.2863 wrong_frac=0.4673 init_acc_corrupt=0.4957 init_gold_top10=0.5276 init_gold_top100=0.6237 rollout_applied_pos_frac=0.6083 init_acc_rollout_applied=0.5890 init_acc_rollout_kept=0.3507 logit_acc_rollout_applied=0.5306 logit_acc_rollout_kept=0.3674 +step=1250 micro_steps=5000 elapsed=341.2s lr=1.251000e-03 loss=4.7094 loss_recon=4.7094 loss_meanflow=0.0000 mean_model_t=0.4944 mean_corrupt_t=0.4944 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5131 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=13.1720 out_g_norm=0.4625 acc_all=0.6578 acc_corrupt=0.5091 corrupt_frac=0.5315 loss_all=3.0109 loss_corrupt=4.1732 acc_corrupt_t_0p0_0p2=0.1025 corrupt_frac_t_0p0_0p2=0.1731 acc_corrupt_t_0p2_0p4=0.2654 corrupt_frac_t_0p2_0p4=0.0578 acc_corrupt_t_0p4_0p6=0.4864 corrupt_frac_t_0p4_0p6=0.3375 acc_corrupt_t_0p6_0p8=0.6503 corrupt_frac_t_0p6_0p8=0.1762 acc_corrupt_t_0p8_1p0=0.7725 corrupt_frac_t_0p8_1p0=0.2554 wrong_frac=0.4378 init_acc_corrupt=0.5339 init_gold_top10=0.5537 init_gold_top100=0.6304 rollout_applied_pos_frac=0.4279 init_acc_rollout_applied=0.5790 init_acc_rollout_kept=0.5002 logit_acc_rollout_applied=0.5432 logit_acc_rollout_kept=0.4836 +step=1300 micro_steps=5200 elapsed=559.8s lr=1.301000e-03 loss=4.5039 loss_recon=4.5039 loss_meanflow=0.0000 mean_model_t=0.5009 mean_corrupt_t=0.5009 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5150 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=13.8504 out_g_norm=0.4625 acc_all=0.6338 acc_corrupt=0.4842 corrupt_frac=0.5438 loss_all=3.1227 loss_corrupt=4.3097 acc_corrupt_t_0p0_0p2=0.1353 corrupt_frac_t_0p0_0p2=0.1824 acc_corrupt_t_0p2_0p4=0.2960 corrupt_frac_t_0p2_0p4=0.2597 acc_corrupt_t_0p4_0p6=0.5003 corrupt_frac_t_0p4_0p6=0.1976 acc_corrupt_t_0p6_0p8=0.6276 corrupt_frac_t_0p6_0p8=0.1302 acc_corrupt_t_0p8_1p0=0.8785 corrupt_frac_t_0p8_1p0=0.2300 wrong_frac=0.4828 init_acc_corrupt=0.4758 init_gold_top10=0.5169 init_gold_top100=0.6259 rollout_applied_pos_frac=0.4475 init_acc_rollout_applied=0.4155 init_acc_rollout_kept=0.5247 logit_acc_rollout_applied=0.4324 logit_acc_rollout_kept=0.5262 +step=1350 micro_steps=5400 elapsed=278.1s lr=1.351000e-03 loss=4.4099 loss_recon=4.4099 loss_meanflow=0.0000 mean_model_t=0.4997 mean_corrupt_t=0.4997 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5200 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=14.5099 out_g_norm=0.5605 acc_all=0.6109 acc_corrupt=0.4587 corrupt_frac=0.5972 loss_all=3.2089 loss_corrupt=4.3981 acc_corrupt_t_0p0_0p2=0.1093 corrupt_frac_t_0p0_0p2=0.2150 acc_corrupt_t_0p2_0p4=0.2805 corrupt_frac_t_0p2_0p4=0.2215 acc_corrupt_t_0p4_0p6=0.4765 corrupt_frac_t_0p4_0p6=0.1628 acc_corrupt_t_0p6_0p8=0.6794 corrupt_frac_t_0p6_0p8=0.1699 acc_corrupt_t_0p8_1p0=0.7801 corrupt_frac_t_0p8_1p0=0.2307 wrong_frac=0.5272 init_acc_corrupt=0.4343 init_gold_top10=0.4725 init_gold_top100=0.5993 rollout_applied_pos_frac=0.4621 init_acc_rollout_applied=0.4161 init_acc_rollout_kept=0.4500 logit_acc_rollout_applied=0.4396 logit_acc_rollout_kept=0.4750 +step=1400 micro_steps=5600 elapsed=278.2s lr=1.401000e-03 loss=4.2566 loss_recon=4.2566 loss_meanflow=0.0000 mean_model_t=0.4997 mean_corrupt_t=0.4997 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4894 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=15.1346 out_g_norm=0.5500 acc_all=0.5632 acc_corrupt=0.4257 corrupt_frac=0.6758 loss_all=3.6485 loss_corrupt=4.7447 acc_corrupt_t_0p0_0p2=0.1160 corrupt_frac_t_0p0_0p2=0.2484 acc_corrupt_t_0p2_0p4=0.2782 corrupt_frac_t_0p2_0p4=0.1974 acc_corrupt_t_0p4_0p6=0.5119 corrupt_frac_t_0p4_0p6=0.2149 acc_corrupt_t_0p6_0p8=0.6236 corrupt_frac_t_0p6_0p8=0.2040 acc_corrupt_t_0p8_1p0=0.7746 corrupt_frac_t_0p8_1p0=0.1353 wrong_frac=0.5439 init_acc_corrupt=0.4136 init_gold_top10=0.4510 init_gold_top100=0.6135 rollout_applied_pos_frac=0.5969 init_acc_rollout_applied=0.3280 init_acc_rollout_kept=0.5403 logit_acc_rollout_applied=0.3532 logit_acc_rollout_kept=0.5332 +step=1450 micro_steps=5800 elapsed=278.3s lr=1.451000e-03 loss=4.1745 loss_recon=4.1745 loss_meanflow=0.0000 mean_model_t=0.4984 mean_corrupt_t=0.4984 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5194 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=15.7149 out_g_norm=0.5593 acc_all=0.6565 acc_corrupt=0.5076 corrupt_frac=0.5837 loss_all=2.8242 loss_corrupt=3.9909 acc_corrupt_t_0p0_0p2=0.1355 corrupt_frac_t_0p0_0p2=0.0887 acc_corrupt_t_0p2_0p4=0.2784 corrupt_frac_t_0p2_0p4=0.3330 acc_corrupt_t_0p4_0p6=0.4989 corrupt_frac_t_0p4_0p6=0.1408 acc_corrupt_t_0p6_0p8=0.7115 corrupt_frac_t_0p6_0p8=0.2956 acc_corrupt_t_0p8_1p0=0.8618 corrupt_frac_t_0p8_1p0=0.1419 wrong_frac=0.4792 init_acc_corrupt=0.4770 init_gold_top10=0.5195 init_gold_top100=0.6280 rollout_applied_pos_frac=0.4129 init_acc_rollout_applied=0.4017 init_acc_rollout_kept=0.5301 logit_acc_rollout_applied=0.4481 logit_acc_rollout_kept=0.5494 +step=1500 micro_steps=6000 elapsed=274.0s lr=1.501000e-03 loss=4.0231 loss_recon=4.0231 loss_meanflow=0.0000 mean_model_t=0.4992 mean_corrupt_t=0.4992 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4894 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=16.2735 out_g_norm=0.5525 acc_all=0.7079 acc_corrupt=0.5495 corrupt_frac=0.4790 loss_all=2.3779 loss_corrupt=3.6365 acc_corrupt_t_0p0_0p2=0.1306 corrupt_frac_t_0p0_0p2=0.2073 acc_corrupt_t_0p2_0p4=0.3318 corrupt_frac_t_0p2_0p4=0.1477 acc_corrupt_t_0p4_0p6=0.5247 corrupt_frac_t_0p4_0p6=0.1133 acc_corrupt_t_0p6_0p8=0.7136 corrupt_frac_t_0p6_0p8=0.3116 acc_corrupt_t_0p8_1p0=0.8704 corrupt_frac_t_0p8_1p0=0.2202 wrong_frac=0.4544 init_acc_corrupt=0.5188 init_gold_top10=0.5527 init_gold_top100=0.6546 rollout_applied_pos_frac=0.5606 init_acc_rollout_applied=0.5681 init_acc_rollout_kept=0.4560 logit_acc_rollout_applied=0.5886 logit_acc_rollout_kept=0.4995 +step=1550 micro_steps=6200 elapsed=267.0s lr=1.551000e-03 loss=3.9425 loss_recon=3.9425 loss_meanflow=0.0000 mean_model_t=0.5030 mean_corrupt_t=0.5030 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4738 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=16.8055 out_g_norm=0.5877 acc_all=0.6624 acc_corrupt=0.4892 corrupt_frac=0.5459 loss_all=2.6594 loss_corrupt=4.0133 acc_corrupt_t_0p0_0p2=0.1696 corrupt_frac_t_0p0_0p2=0.2996 acc_corrupt_t_0p2_0p4=0.3187 corrupt_frac_t_0p2_0p4=0.2214 acc_corrupt_t_0p4_0p6=0.5677 corrupt_frac_t_0p4_0p6=0.0685 acc_corrupt_t_0p6_0p8=0.6978 corrupt_frac_t_0p6_0p8=0.1341 acc_corrupt_t_0p8_1p0=0.8515 corrupt_frac_t_0p8_1p0=0.2764 wrong_frac=0.5154 init_acc_corrupt=0.4341 init_gold_top10=0.4843 init_gold_top100=0.5945 rollout_applied_pos_frac=0.3420 init_acc_rollout_applied=0.4443 init_acc_rollout_kept=0.4289 logit_acc_rollout_applied=0.4879 logit_acc_rollout_kept=0.4899 +step=1600 micro_steps=6400 elapsed=264.6s lr=1.601000e-03 loss=3.7844 loss_recon=3.7844 loss_meanflow=0.0000 mean_model_t=0.5100 mean_corrupt_t=0.5100 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5056 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=17.3138 out_g_norm=0.5906 acc_all=0.7163 acc_corrupt=0.5746 corrupt_frac=0.5432 loss_all=2.2325 loss_corrupt=3.3410 acc_corrupt_t_0p0_0p2=0.2214 corrupt_frac_t_0p0_0p2=0.2639 acc_corrupt_t_0p2_0p4=0.3928 corrupt_frac_t_0p2_0p4=0.1370 acc_corrupt_t_0p4_0p6=0.5770 corrupt_frac_t_0p4_0p6=0.0503 acc_corrupt_t_0p6_0p8=0.7035 corrupt_frac_t_0p6_0p8=0.2783 acc_corrupt_t_0p8_1p0=0.8786 corrupt_frac_t_0p8_1p0=0.2704 wrong_frac=0.4544 init_acc_corrupt=0.5099 init_gold_top10=0.5540 init_gold_top100=0.6833 rollout_applied_pos_frac=0.5636 init_acc_rollout_applied=0.5373 init_acc_rollout_kept=0.4744 logit_acc_rollout_applied=0.6063 logit_acc_rollout_kept=0.5338 +step=1650 micro_steps=6600 elapsed=264.3s lr=1.651000e-03 loss=3.7561 loss_recon=3.7561 loss_meanflow=0.0000 mean_model_t=0.4999 mean_corrupt_t=0.4999 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=17.7890 out_g_norm=0.6241 acc_all=0.7121 acc_corrupt=0.5480 corrupt_frac=0.5311 loss_all=2.2435 loss_corrupt=3.5350 acc_corrupt_t_0p0_0p2=0.1544 corrupt_frac_t_0p0_0p2=0.2009 acc_corrupt_t_0p2_0p4=0.2983 corrupt_frac_t_0p2_0p4=0.1728 acc_corrupt_t_0p4_0p6=0.5744 corrupt_frac_t_0p4_0p6=0.1046 acc_corrupt_t_0p6_0p8=0.7294 corrupt_frac_t_0p6_0p8=0.3498 acc_corrupt_t_0p8_1p0=0.8740 corrupt_frac_t_0p8_1p0=0.1719 wrong_frac=0.4612 init_acc_corrupt=0.4978 init_gold_top10=0.5428 init_gold_top100=0.6657 rollout_applied_pos_frac=0.4735 init_acc_rollout_applied=0.4135 init_acc_rollout_kept=0.5737 logit_acc_rollout_applied=0.4854 logit_acc_rollout_kept=0.6043 +step=1700 micro_steps=6800 elapsed=270.5s lr=1.701000e-03 loss=3.6896 loss_recon=3.6896 loss_meanflow=0.0000 mean_model_t=0.5030 mean_corrupt_t=0.5030 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5019 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=18.2286 out_g_norm=0.6218 acc_all=0.6959 acc_corrupt=0.4931 corrupt_frac=0.5295 loss_all=2.3498 loss_corrupt=3.8868 acc_corrupt_t_0p0_0p2=0.1452 corrupt_frac_t_0p0_0p2=0.1929 acc_corrupt_t_0p2_0p4=0.2718 corrupt_frac_t_0p2_0p4=0.1860 acc_corrupt_t_0p4_0p6=0.5666 corrupt_frac_t_0p4_0p6=0.3642 acc_corrupt_t_0p6_0p8=0.7312 corrupt_frac_t_0p6_0p8=0.1438 acc_corrupt_t_0p8_1p0=0.9113 corrupt_frac_t_0p8_1p0=0.1131 wrong_frac=0.5345 init_acc_corrupt=0.4287 init_gold_top10=0.4676 init_gold_top100=0.5927 rollout_applied_pos_frac=0.4964 init_acc_rollout_applied=0.5217 init_acc_rollout_kept=0.3371 logit_acc_rollout_applied=0.5792 logit_acc_rollout_kept=0.4083 +step=1750 micro_steps=7000 elapsed=277.4s lr=1.751000e-03 loss=3.6468 loss_recon=3.6468 loss_meanflow=0.0000 mean_model_t=0.4980 mean_corrupt_t=0.4980 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4944 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=18.6327 out_g_norm=0.6334 acc_all=0.7358 acc_corrupt=0.6029 corrupt_frac=0.5933 loss_all=1.9813 loss_corrupt=2.9757 acc_corrupt_t_0p0_0p2=0.0944 corrupt_frac_t_0p0_0p2=0.0926 acc_corrupt_t_0p2_0p4=0.3325 corrupt_frac_t_0p2_0p4=0.0840 acc_corrupt_t_0p4_0p6=0.5496 corrupt_frac_t_0p4_0p6=0.3580 acc_corrupt_t_0p6_0p8=0.7510 corrupt_frac_t_0p6_0p8=0.2582 acc_corrupt_t_0p8_1p0=0.8473 corrupt_frac_t_0p8_1p0=0.2071 wrong_frac=0.4201 init_acc_corrupt=0.5652 init_gold_top10=0.5802 init_gold_top100=0.6551 rollout_applied_pos_frac=0.2696 init_acc_rollout_applied=0.4210 init_acc_rollout_kept=0.6185 logit_acc_rollout_applied=0.4937 logit_acc_rollout_kept=0.6432 +step=1800 micro_steps=7200 elapsed=277.7s lr=1.801000e-03 loss=3.5736 loss_recon=3.5736 loss_meanflow=0.0000 mean_model_t=0.4945 mean_corrupt_t=0.4945 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5075 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=19.0009 out_g_norm=0.6702 acc_all=0.6434 acc_corrupt=0.4779 corrupt_frac=0.6177 loss_all=2.6892 loss_corrupt=3.9386 acc_corrupt_t_0p0_0p2=0.1058 corrupt_frac_t_0p0_0p2=0.2685 acc_corrupt_t_0p2_0p4=0.3417 corrupt_frac_t_0p2_0p4=0.1713 acc_corrupt_t_0p4_0p6=0.5731 corrupt_frac_t_0p4_0p6=0.2906 acc_corrupt_t_0p6_0p8=0.7499 corrupt_frac_t_0p6_0p8=0.1033 acc_corrupt_t_0p8_1p0=0.8841 corrupt_frac_t_0p8_1p0=0.1662 wrong_frac=0.5633 init_acc_corrupt=0.4106 init_gold_top10=0.4458 init_gold_top100=0.6241 rollout_applied_pos_frac=0.5480 init_acc_rollout_applied=0.3446 init_acc_rollout_kept=0.4907 logit_acc_rollout_applied=0.4239 logit_acc_rollout_kept=0.5433 +step=1850 micro_steps=7400 elapsed=277.5s lr=1.851000e-03 loss=3.4267 loss_recon=3.4267 loss_meanflow=0.0000 mean_model_t=0.5117 mean_corrupt_t=0.5117 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4863 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=19.3337 out_g_norm=0.7106 acc_all=0.6932 acc_corrupt=0.5865 corrupt_frac=0.6867 loss_all=2.3060 loss_corrupt=3.1217 acc_corrupt_t_0p0_0p2=0.1847 corrupt_frac_t_0p0_0p2=0.1427 acc_corrupt_t_0p2_0p4=0.3302 corrupt_frac_t_0p2_0p4=0.2143 acc_corrupt_t_0p4_0p6=0.5179 corrupt_frac_t_0p4_0p6=0.0757 acc_corrupt_t_0p6_0p8=0.7169 corrupt_frac_t_0p6_0p8=0.2923 acc_corrupt_t_0p8_1p0=0.8749 corrupt_frac_t_0p8_1p0=0.2750 wrong_frac=0.4343 init_acc_corrupt=0.5255 init_gold_top10=0.5658 init_gold_top100=0.6943 rollout_applied_pos_frac=0.4990 init_acc_rollout_applied=0.4154 init_acc_rollout_kept=0.6353 logit_acc_rollout_applied=0.4992 logit_acc_rollout_kept=0.6733 +step=1900 micro_steps=7600 elapsed=277.8s lr=1.901000e-03 loss=3.4977 loss_recon=3.4977 loss_meanflow=0.0000 mean_model_t=0.4974 mean_corrupt_t=0.4974 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5112 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=19.6312 out_g_norm=0.7519 acc_all=0.7122 acc_corrupt=0.5321 corrupt_frac=0.5406 loss_all=2.1233 loss_corrupt=3.4752 acc_corrupt_t_0p0_0p2=0.1618 corrupt_frac_t_0p0_0p2=0.2734 acc_corrupt_t_0p2_0p4=0.3675 corrupt_frac_t_0p2_0p4=0.0925 acc_corrupt_t_0p4_0p6=0.5947 corrupt_frac_t_0p4_0p6=0.2859 acc_corrupt_t_0p6_0p8=0.7141 corrupt_frac_t_0p6_0p8=0.1935 acc_corrupt_t_0p8_1p0=0.9413 corrupt_frac_t_0p8_1p0=0.1547 wrong_frac=0.5094 init_acc_corrupt=0.4582 init_gold_top10=0.4915 init_gold_top100=0.6388 rollout_applied_pos_frac=0.5608 init_acc_rollout_applied=0.4556 init_acc_rollout_kept=0.4616 logit_acc_rollout_applied=0.5233 logit_acc_rollout_kept=0.5432 +step=1950 micro_steps=7800 elapsed=278.5s lr=1.951000e-03 loss=3.4228 loss_recon=3.4228 loss_meanflow=0.0000 mean_model_t=0.4960 mean_corrupt_t=0.4960 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5031 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=19.8973 out_g_norm=0.7806 acc_all=0.7165 acc_corrupt=0.5613 corrupt_frac=0.5928 loss_all=2.1039 loss_corrupt=3.2575 acc_corrupt_t_0p0_0p2=0.1385 corrupt_frac_t_0p0_0p2=0.1688 acc_corrupt_t_0p2_0p4=0.3287 corrupt_frac_t_0p2_0p4=0.2236 acc_corrupt_t_0p4_0p6=0.5633 corrupt_frac_t_0p4_0p6=0.1578 acc_corrupt_t_0p6_0p8=0.7262 corrupt_frac_t_0p6_0p8=0.1957 acc_corrupt_t_0p8_1p0=0.9187 corrupt_frac_t_0p8_1p0=0.2540 wrong_frac=0.4681 init_acc_corrupt=0.4947 init_gold_top10=0.5380 init_gold_top100=0.6960 rollout_applied_pos_frac=0.6823 init_acc_rollout_applied=0.4772 init_acc_rollout_kept=0.5323 logit_acc_rollout_applied=0.5520 logit_acc_rollout_kept=0.5813 +step=2000 micro_steps=8000 elapsed=276.0s lr=2.000000e-03 loss=3.3301 loss_recon=3.3301 loss_meanflow=0.0000 mean_model_t=0.5069 mean_corrupt_t=0.5069 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4963 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=20.1425 out_g_norm=0.8486 acc_all=0.6762 acc_corrupt=0.4906 corrupt_frac=0.5719 loss_all=2.3574 loss_corrupt=3.7389 acc_corrupt_t_0p0_0p2=0.1373 corrupt_frac_t_0p0_0p2=0.3020 acc_corrupt_t_0p2_0p4=0.3273 corrupt_frac_t_0p2_0p4=0.2137 acc_corrupt_t_0p4_0p6=0.5747 corrupt_frac_t_0p4_0p6=0.1268 acc_corrupt_t_0p6_0p8=0.7462 corrupt_frac_t_0p6_0p8=0.1249 acc_corrupt_t_0p8_1p0=0.9165 corrupt_frac_t_0p8_1p0=0.2326 wrong_frac=0.5519 init_acc_corrupt=0.4095 init_gold_top10=0.4569 init_gold_top100=0.5909 rollout_applied_pos_frac=0.3363 init_acc_rollout_applied=0.2416 init_acc_rollout_kept=0.4946 logit_acc_rollout_applied=0.3628 logit_acc_rollout_kept=0.5554 +step=2050 micro_steps=8200 elapsed=268.7s lr=2.000000e-03 loss=3.3704 loss_recon=3.3704 loss_meanflow=0.0000 mean_model_t=0.4972 mean_corrupt_t=0.4972 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4688 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=20.3714 out_g_norm=0.8458 acc_all=0.7722 acc_corrupt=0.6025 corrupt_frac=0.5279 loss_all=1.6523 loss_corrupt=2.8713 acc_corrupt_t_0p0_0p2=0.1418 corrupt_frac_t_0p0_0p2=0.0876 acc_corrupt_t_0p2_0p4=0.3884 corrupt_frac_t_0p2_0p4=0.2429 acc_corrupt_t_0p4_0p6=0.5487 corrupt_frac_t_0p4_0p6=0.1957 acc_corrupt_t_0p6_0p8=0.7469 corrupt_frac_t_0p6_0p8=0.2880 acc_corrupt_t_0p8_1p0=0.9325 corrupt_frac_t_0p8_1p0=0.1857 wrong_frac=0.4481 init_acc_corrupt=0.5319 init_gold_top10=0.5581 init_gold_top100=0.6473 rollout_applied_pos_frac=0.3375 init_acc_rollout_applied=0.4930 init_acc_rollout_kept=0.5517 logit_acc_rollout_applied=0.5606 logit_acc_rollout_kept=0.6238 +step=2100 micro_steps=8400 elapsed=263.5s lr=2.000000e-03 loss=3.3094 loss_recon=3.3094 loss_meanflow=0.0000 mean_model_t=0.4993 mean_corrupt_t=0.4993 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5081 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=20.5781 out_g_norm=0.8500 acc_all=0.7602 acc_corrupt=0.5741 corrupt_frac=0.5172 loss_all=1.7656 loss_corrupt=3.1339 acc_corrupt_t_0p0_0p2=0.1564 corrupt_frac_t_0p0_0p2=0.1800 acc_corrupt_t_0p2_0p4=0.3479 corrupt_frac_t_0p2_0p4=0.2208 acc_corrupt_t_0p4_0p6=0.4897 corrupt_frac_t_0p4_0p6=0.0917 acc_corrupt_t_0p6_0p8=0.7086 corrupt_frac_t_0p6_0p8=0.1825 acc_corrupt_t_0p8_1p0=0.9074 corrupt_frac_t_0p8_1p0=0.3251 wrong_frac=0.4591 init_acc_corrupt=0.4993 init_gold_top10=0.5483 init_gold_top100=0.6749 rollout_applied_pos_frac=0.4897 init_acc_rollout_applied=0.5040 init_acc_rollout_kept=0.4947 logit_acc_rollout_applied=0.5868 logit_acc_rollout_kept=0.5620 +step=2150 micro_steps=8600 elapsed=263.4s lr=2.000000e-03 loss=3.1861 loss_recon=3.1861 loss_meanflow=0.0000 mean_model_t=0.5103 mean_corrupt_t=0.5103 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5006 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=20.7717 out_g_norm=0.8299 acc_all=0.7310 acc_corrupt=0.5472 corrupt_frac=0.5407 loss_all=1.9419 loss_corrupt=3.2695 acc_corrupt_t_0p0_0p2=0.1235 corrupt_frac_t_0p0_0p2=0.2194 acc_corrupt_t_0p2_0p4=0.3873 corrupt_frac_t_0p2_0p4=0.1275 acc_corrupt_t_0p4_0p6=0.5661 corrupt_frac_t_0p4_0p6=0.2375 acc_corrupt_t_0p6_0p8=0.7628 corrupt_frac_t_0p6_0p8=0.2625 acc_corrupt_t_0p8_1p0=0.8890 corrupt_frac_t_0p8_1p0=0.1531 wrong_frac=0.5148 init_acc_corrupt=0.4653 init_gold_top10=0.4997 init_gold_top100=0.6562 rollout_applied_pos_frac=0.5454 init_acc_rollout_applied=0.3880 init_acc_rollout_kept=0.5580 logit_acc_rollout_applied=0.4826 logit_acc_rollout_kept=0.6248 +step=2200 micro_steps=8800 elapsed=263.7s lr=2.000000e-03 loss=3.2882 loss_recon=3.2882 loss_meanflow=0.0000 mean_model_t=0.4989 mean_corrupt_t=0.4989 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5025 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=20.9529 out_g_norm=0.8820 acc_all=0.7820 acc_corrupt=0.6246 corrupt_frac=0.5444 loss_all=1.5756 loss_corrupt=2.7094 acc_corrupt_t_0p0_0p2=0.2103 corrupt_frac_t_0p0_0p2=0.0488 acc_corrupt_t_0p2_0p4=0.2990 corrupt_frac_t_0p2_0p4=0.1759 acc_corrupt_t_0p4_0p6=0.5410 corrupt_frac_t_0p4_0p6=0.3659 acc_corrupt_t_0p6_0p8=0.7766 corrupt_frac_t_0p6_0p8=0.1089 acc_corrupt_t_0p8_1p0=0.9291 corrupt_frac_t_0p8_1p0=0.3005 wrong_frac=0.4229 init_acc_corrupt=0.5516 init_gold_top10=0.5836 init_gold_top100=0.6959 rollout_applied_pos_frac=0.6028 init_acc_rollout_applied=0.6055 init_acc_rollout_kept=0.4697 logit_acc_rollout_applied=0.6641 logit_acc_rollout_kept=0.5647 +step=2250 micro_steps=9000 elapsed=263.9s lr=2.000000e-03 loss=3.2591 loss_recon=3.2591 loss_meanflow=0.0000 mean_model_t=0.4964 mean_corrupt_t=0.4964 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5050 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=21.1262 out_g_norm=0.8852 acc_all=0.7484 acc_corrupt=0.5326 corrupt_frac=0.4933 loss_all=1.7977 loss_corrupt=3.3162 acc_corrupt_t_0p0_0p2=0.1821 corrupt_frac_t_0p0_0p2=0.1970 acc_corrupt_t_0p2_0p4=0.3622 corrupt_frac_t_0p2_0p4=0.2314 acc_corrupt_t_0p4_0p6=0.6032 corrupt_frac_t_0p4_0p6=0.2529 acc_corrupt_t_0p6_0p8=0.7822 corrupt_frac_t_0p6_0p8=0.1937 acc_corrupt_t_0p8_1p0=0.8713 corrupt_frac_t_0p8_1p0=0.1250 wrong_frac=0.5345 init_acc_corrupt=0.4313 init_gold_top10=0.4697 init_gold_top100=0.6075 rollout_applied_pos_frac=0.4559 init_acc_rollout_applied=0.4414 init_acc_rollout_kept=0.4228 logit_acc_rollout_applied=0.5451 logit_acc_rollout_kept=0.5222 +step=2300 micro_steps=9200 elapsed=264.1s lr=2.000000e-03 loss=3.2508 loss_recon=3.2508 loss_meanflow=0.0000 mean_model_t=0.4930 mean_corrupt_t=0.4930 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=21.2907 out_g_norm=0.8736 acc_all=0.7623 acc_corrupt=0.5784 corrupt_frac=0.5175 loss_all=1.6827 loss_corrupt=2.9699 acc_corrupt_t_0p0_0p2=0.2089 corrupt_frac_t_0p0_0p2=0.1623 acc_corrupt_t_0p2_0p4=0.3865 corrupt_frac_t_0p2_0p4=0.2335 acc_corrupt_t_0p4_0p6=0.5739 corrupt_frac_t_0p4_0p6=0.1720 acc_corrupt_t_0p6_0p8=0.7552 corrupt_frac_t_0p6_0p8=0.2392 acc_corrupt_t_0p8_1p0=0.9062 corrupt_frac_t_0p8_1p0=0.1930 wrong_frac=0.4840 init_acc_corrupt=0.4820 init_gold_top10=0.5242 init_gold_top100=0.6954 rollout_applied_pos_frac=0.6655 init_acc_rollout_applied=0.4754 init_acc_rollout_kept=0.4952 logit_acc_rollout_applied=0.5696 logit_acc_rollout_kept=0.5958 +step=2350 micro_steps=9400 elapsed=264.5s lr=2.000000e-03 loss=3.0471 loss_recon=3.0471 loss_meanflow=0.0000 mean_model_t=0.5118 mean_corrupt_t=0.5118 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4919 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=21.4510 out_g_norm=0.8746 acc_all=0.7124 acc_corrupt=0.5206 corrupt_frac=0.5546 loss_all=2.0445 loss_corrupt=3.4060 acc_corrupt_t_0p0_0p2=0.1502 corrupt_frac_t_0p0_0p2=0.3165 acc_corrupt_t_0p2_0p4=0.4398 corrupt_frac_t_0p2_0p4=0.1919 acc_corrupt_t_0p4_0p6=0.6200 corrupt_frac_t_0p4_0p6=0.1651 acc_corrupt_t_0p6_0p8=0.7571 corrupt_frac_t_0p6_0p8=0.1287 acc_corrupt_t_0p8_1p0=0.9547 corrupt_frac_t_0p8_1p0=0.1979 wrong_frac=0.5400 init_acc_corrupt=0.4241 init_gold_top10=0.4709 init_gold_top100=0.5827 rollout_applied_pos_frac=0.4642 init_acc_rollout_applied=0.5534 init_acc_rollout_kept=0.3122 logit_acc_rollout_applied=0.6370 logit_acc_rollout_kept=0.4198 +step=2400 micro_steps=9600 elapsed=264.4s lr=2.000000e-03 loss=3.0637 loss_recon=3.0637 loss_meanflow=0.0000 mean_model_t=0.5136 mean_corrupt_t=0.5136 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5006 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=21.6045 out_g_norm=0.8667 acc_all=0.7271 acc_corrupt=0.5838 corrupt_frac=0.6318 loss_all=1.9896 loss_corrupt=3.0226 acc_corrupt_t_0p0_0p2=0.1527 corrupt_frac_t_0p0_0p2=0.2110 acc_corrupt_t_0p2_0p4=0.3699 corrupt_frac_t_0p2_0p4=0.1617 acc_corrupt_t_0p4_0p6=0.5767 corrupt_frac_t_0p4_0p6=0.1392 acc_corrupt_t_0p6_0p8=0.7418 corrupt_frac_t_0p6_0p8=0.2273 acc_corrupt_t_0p8_1p0=0.9315 corrupt_frac_t_0p8_1p0=0.2608 wrong_frac=0.4554 init_acc_corrupt=0.5102 init_gold_top10=0.5548 init_gold_top100=0.6712 rollout_applied_pos_frac=0.5781 init_acc_rollout_applied=0.5406 init_acc_rollout_kept=0.4685 logit_acc_rollout_applied=0.6181 logit_acc_rollout_kept=0.5369 +step=2450 micro_steps=9800 elapsed=264.7s lr=2.000000e-03 loss=3.2117 loss_recon=3.2117 loss_meanflow=0.0000 mean_model_t=0.4904 mean_corrupt_t=0.4904 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4956 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=21.7566 out_g_norm=0.8815 acc_all=0.6920 acc_corrupt=0.5209 corrupt_frac=0.6182 loss_all=2.1815 loss_corrupt=3.3812 acc_corrupt_t_0p0_0p2=0.1232 corrupt_frac_t_0p0_0p2=0.1959 acc_corrupt_t_0p2_0p4=0.2833 corrupt_frac_t_0p2_0p4=0.2478 acc_corrupt_t_0p4_0p6=0.5993 corrupt_frac_t_0p4_0p6=0.2048 acc_corrupt_t_0p6_0p8=0.7699 corrupt_frac_t_0p6_0p8=0.1568 acc_corrupt_t_0p8_1p0=0.9404 corrupt_frac_t_0p8_1p0=0.1947 wrong_frac=0.5267 init_acc_corrupt=0.4322 init_gold_top10=0.4894 init_gold_top100=0.6555 rollout_applied_pos_frac=0.6059 init_acc_rollout_applied=0.4189 init_acc_rollout_kept=0.4526 logit_acc_rollout_applied=0.5035 logit_acc_rollout_kept=0.5477 +step=2500 micro_steps=10000 elapsed=265.1s lr=2.000000e-03 loss=3.1611 loss_recon=3.1611 loss_meanflow=0.0000 mean_model_t=0.4926 mean_corrupt_t=0.4926 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5069 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=21.9040 out_g_norm=0.8585 acc_all=0.7928 acc_corrupt=0.6473 corrupt_frac=0.5497 loss_all=1.4272 loss_corrupt=2.4159 acc_corrupt_t_0p0_0p2=0.1924 corrupt_frac_t_0p0_0p2=0.1529 acc_corrupt_t_0p2_0p4=0.3713 corrupt_frac_t_0p2_0p4=0.1803 acc_corrupt_t_0p4_0p6=0.5746 corrupt_frac_t_0p4_0p6=0.1216 acc_corrupt_t_0p6_0p8=0.8088 corrupt_frac_t_0p6_0p8=0.1847 acc_corrupt_t_0p8_1p0=0.9201 corrupt_frac_t_0p8_1p0=0.3604 wrong_frac=0.4087 init_acc_corrupt=0.5594 init_gold_top10=0.6016 init_gold_top100=0.6526 rollout_applied_pos_frac=0.3019 init_acc_rollout_applied=0.7474 init_acc_rollout_kept=0.4781 logit_acc_rollout_applied=0.8084 logit_acc_rollout_kept=0.5776 +step=2550 micro_steps=10200 elapsed=269.4s lr=2.000000e-03 loss=3.0997 loss_recon=3.0997 loss_meanflow=0.0000 mean_model_t=0.4939 mean_corrupt_t=0.4939 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5038 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.0483 out_g_norm=0.8923 acc_all=0.7586 acc_corrupt=0.6190 corrupt_frac=0.5992 loss_all=1.6787 loss_corrupt=2.6280 acc_corrupt_t_0p0_0p2=0.1812 corrupt_frac_t_0p0_0p2=0.1456 acc_corrupt_t_0p2_0p4=0.3782 corrupt_frac_t_0p2_0p4=0.0964 acc_corrupt_t_0p4_0p6=0.5968 corrupt_frac_t_0p4_0p6=0.2844 acc_corrupt_t_0p6_0p8=0.7668 corrupt_frac_t_0p6_0p8=0.3263 acc_corrupt_t_0p8_1p0=0.9253 corrupt_frac_t_0p8_1p0=0.1473 wrong_frac=0.4458 init_acc_corrupt=0.5374 init_gold_top10=0.5689 init_gold_top100=0.6974 rollout_applied_pos_frac=0.6147 init_acc_rollout_applied=0.5565 init_acc_rollout_kept=0.5069 logit_acc_rollout_applied=0.6364 logit_acc_rollout_kept=0.5914 +step=2600 micro_steps=10400 elapsed=278.6s lr=2.000000e-03 loss=3.0558 loss_recon=3.0558 loss_meanflow=0.0000 mean_model_t=0.4995 mean_corrupt_t=0.4995 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4925 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.1896 out_g_norm=0.8873 acc_all=0.7320 acc_corrupt=0.5088 corrupt_frac=0.5120 loss_all=1.9061 loss_corrupt=3.4737 acc_corrupt_t_0p0_0p2=0.1629 corrupt_frac_t_0p0_0p2=0.2993 acc_corrupt_t_0p2_0p4=0.3768 corrupt_frac_t_0p2_0p4=0.2235 acc_corrupt_t_0p4_0p6=0.5495 corrupt_frac_t_0p4_0p6=0.1498 acc_corrupt_t_0p6_0p8=0.7378 corrupt_frac_t_0p6_0p8=0.0796 acc_corrupt_t_0p8_1p0=0.9476 corrupt_frac_t_0p8_1p0=0.2478 wrong_frac=0.5540 init_acc_corrupt=0.4008 init_gold_top10=0.4521 init_gold_top100=0.6336 rollout_applied_pos_frac=0.5059 init_acc_rollout_applied=0.3250 init_acc_rollout_kept=0.4785 logit_acc_rollout_applied=0.4506 logit_acc_rollout_kept=0.5685 +step=2650 micro_steps=10600 elapsed=279.9s lr=2.000000e-03 loss=3.1272 loss_recon=3.1272 loss_meanflow=0.0000 mean_model_t=0.4976 mean_corrupt_t=0.4976 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5106 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.3288 out_g_norm=0.8934 acc_all=0.7856 acc_corrupt=0.6205 corrupt_frac=0.5455 loss_all=1.5233 loss_corrupt=2.6794 acc_corrupt_t_0p0_0p2=0.1493 corrupt_frac_t_0p0_0p2=0.1255 acc_corrupt_t_0p2_0p4=0.2775 corrupt_frac_t_0p2_0p4=0.1713 acc_corrupt_t_0p4_0p6=0.5836 corrupt_frac_t_0p4_0p6=0.0451 acc_corrupt_t_0p6_0p8=0.7557 corrupt_frac_t_0p6_0p8=0.4472 acc_corrupt_t_0p8_1p0=0.9010 corrupt_frac_t_0p8_1p0=0.2108 wrong_frac=0.4275 init_acc_corrupt=0.5389 init_gold_top10=0.5820 init_gold_top100=0.6819 rollout_applied_pos_frac=0.5437 init_acc_rollout_applied=0.6258 init_acc_rollout_kept=0.4355 logit_acc_rollout_applied=0.6866 logit_acc_rollout_kept=0.5417 +step=2700 micro_steps=10800 elapsed=279.9s lr=2.000000e-03 loss=3.0159 loss_recon=3.0159 loss_meanflow=0.0000 mean_model_t=0.4962 mean_corrupt_t=0.4962 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5000 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.4673 out_g_norm=0.8728 acc_all=0.7399 acc_corrupt=0.5344 corrupt_frac=0.5303 loss_all=1.7889 loss_corrupt=3.1838 acc_corrupt_t_0p0_0p2=0.1935 corrupt_frac_t_0p0_0p2=0.2290 acc_corrupt_t_0p2_0p4=0.3867 corrupt_frac_t_0p2_0p4=0.1412 acc_corrupt_t_0p4_0p6=0.6033 corrupt_frac_t_0p4_0p6=0.3256 acc_corrupt_t_0p6_0p8=0.7582 corrupt_frac_t_0p6_0p8=0.2676 acc_corrupt_t_0p8_1p0=0.9859 corrupt_frac_t_0p8_1p0=0.0367 wrong_frac=0.5431 init_acc_corrupt=0.4195 init_gold_top10=0.4683 init_gold_top100=0.6279 rollout_applied_pos_frac=0.5205 init_acc_rollout_applied=0.3923 init_acc_rollout_kept=0.4491 logit_acc_rollout_applied=0.5009 logit_acc_rollout_kept=0.5707 +step=2750 micro_steps=11000 elapsed=279.7s lr=2.000000e-03 loss=3.0169 loss_recon=3.0169 loss_meanflow=0.0000 mean_model_t=0.5017 mean_corrupt_t=0.5017 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5081 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.6038 out_g_norm=0.8797 acc_all=0.7472 acc_corrupt=0.5398 corrupt_frac=0.5294 loss_all=1.7850 loss_corrupt=3.2295 acc_corrupt_t_0p0_0p2=0.1413 corrupt_frac_t_0p0_0p2=0.1457 acc_corrupt_t_0p2_0p4=0.3139 corrupt_frac_t_0p2_0p4=0.3046 acc_corrupt_t_0p4_0p6=0.6354 corrupt_frac_t_0p4_0p6=0.1249 acc_corrupt_t_0p6_0p8=0.7746 corrupt_frac_t_0p6_0p8=0.3430 acc_corrupt_t_0p8_1p0=0.9599 corrupt_frac_t_0p8_1p0=0.0818 wrong_frac=0.5113 init_acc_corrupt=0.4454 init_gold_top10=0.4961 init_gold_top100=0.6860 rollout_applied_pos_frac=0.7011 init_acc_rollout_applied=0.4293 init_acc_rollout_kept=0.4834 logit_acc_rollout_applied=0.5247 logit_acc_rollout_kept=0.5752 +step=2800 micro_steps=11200 elapsed=279.3s lr=2.000000e-03 loss=2.9907 loss_recon=2.9907 loss_meanflow=0.0000 mean_model_t=0.5067 mean_corrupt_t=0.5067 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4894 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.7393 out_g_norm=0.8459 acc_all=0.7129 acc_corrupt=0.5082 corrupt_frac=0.5676 loss_all=2.0253 loss_corrupt=3.4539 acc_corrupt_t_0p0_0p2=0.1499 corrupt_frac_t_0p0_0p2=0.2755 acc_corrupt_t_0p2_0p4=0.3804 corrupt_frac_t_0p2_0p4=0.2191 acc_corrupt_t_0p4_0p6=0.6016 corrupt_frac_t_0p4_0p6=0.2023 acc_corrupt_t_0p6_0p8=0.7833 corrupt_frac_t_0p6_0p8=0.1332 acc_corrupt_t_0p8_1p0=0.9275 corrupt_frac_t_0p8_1p0=0.1698 wrong_frac=0.5482 init_acc_corrupt=0.4053 init_gold_top10=0.4540 init_gold_top100=0.5938 rollout_applied_pos_frac=0.3998 init_acc_rollout_applied=0.4265 init_acc_rollout_kept=0.3911 logit_acc_rollout_applied=0.5400 logit_acc_rollout_kept=0.4871 +step=2850 micro_steps=11400 elapsed=278.0s lr=2.000000e-03 loss=2.9005 loss_recon=2.9005 loss_meanflow=0.0000 mean_model_t=0.5088 mean_corrupt_t=0.5088 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4813 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.8696 out_g_norm=0.8516 acc_all=0.7343 acc_corrupt=0.4893 corrupt_frac=0.4973 loss_all=1.8236 loss_corrupt=3.4766 acc_corrupt_t_0p0_0p2=0.1971 corrupt_frac_t_0p0_0p2=0.3578 acc_corrupt_t_0p2_0p4=0.3234 corrupt_frac_t_0p2_0p4=0.1480 acc_corrupt_t_0p4_0p6=0.6000 corrupt_frac_t_0p4_0p6=0.2292 acc_corrupt_t_0p6_0p8=0.7729 corrupt_frac_t_0p6_0p8=0.1059 acc_corrupt_t_0p8_1p0=0.9529 corrupt_frac_t_0p8_1p0=0.1591 wrong_frac=0.5871 init_acc_corrupt=0.3643 init_gold_top10=0.4161 init_gold_top100=0.6162 rollout_applied_pos_frac=0.5218 init_acc_rollout_applied=0.3572 init_acc_rollout_kept=0.3719 logit_acc_rollout_applied=0.4907 logit_acc_rollout_kept=0.4878 +step=2900 micro_steps=11600 elapsed=266.8s lr=2.000000e-03 loss=3.0185 loss_recon=3.0185 loss_meanflow=0.0000 mean_model_t=0.4956 mean_corrupt_t=0.4956 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5075 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=22.9990 out_g_norm=0.8388 acc_all=0.7660 acc_corrupt=0.5665 corrupt_frac=0.5200 loss_all=1.5919 loss_corrupt=2.9105 acc_corrupt_t_0p0_0p2=0.2131 corrupt_frac_t_0p0_0p2=0.1234 acc_corrupt_t_0p2_0p4=0.3550 corrupt_frac_t_0p2_0p4=0.3505 acc_corrupt_t_0p4_0p6=0.5740 corrupt_frac_t_0p4_0p6=0.1522 acc_corrupt_t_0p6_0p8=0.7965 corrupt_frac_t_0p6_0p8=0.1964 acc_corrupt_t_0p8_1p0=0.9686 corrupt_frac_t_0p8_1p0=0.1775 wrong_frac=0.4995 init_acc_corrupt=0.4569 init_gold_top10=0.5096 init_gold_top100=0.6899 rollout_applied_pos_frac=0.5554 init_acc_rollout_applied=0.3925 init_acc_rollout_kept=0.5373 logit_acc_rollout_applied=0.5132 logit_acc_rollout_kept=0.6331 +step=2950 micro_steps=11800 elapsed=262.5s lr=2.000000e-03 loss=3.0239 loss_recon=3.0239 loss_meanflow=0.0000 mean_model_t=0.4951 mean_corrupt_t=0.4951 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5019 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.1276 out_g_norm=0.8414 acc_all=0.7788 acc_corrupt=0.5877 corrupt_frac=0.5163 loss_all=1.5402 loss_corrupt=2.8420 acc_corrupt_t_0p0_0p2=0.1514 corrupt_frac_t_0p0_0p2=0.2651 acc_corrupt_t_0p2_0p4=0.3842 corrupt_frac_t_0p2_0p4=0.1049 acc_corrupt_t_0p4_0p6=0.6123 corrupt_frac_t_0p4_0p6=0.1474 acc_corrupt_t_0p6_0p8=0.7359 corrupt_frac_t_0p6_0p8=0.1958 acc_corrupt_t_0p8_1p0=0.9518 corrupt_frac_t_0p8_1p0=0.2868 wrong_frac=0.4747 init_acc_corrupt=0.4986 init_gold_top10=0.5448 init_gold_top100=0.7145 rollout_applied_pos_frac=0.6933 init_acc_rollout_applied=0.5269 init_acc_rollout_kept=0.4346 logit_acc_rollout_applied=0.6130 logit_acc_rollout_kept=0.5305 +step=3000 micro_steps=12000 elapsed=261.7s lr=2.000000e-03 loss=2.9584 loss_recon=2.9584 loss_meanflow=0.0000 mean_model_t=0.5043 mean_corrupt_t=0.5043 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4806 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.2542 out_g_norm=0.8076 acc_all=0.8241 acc_corrupt=0.6699 corrupt_frac=0.5168 loss_all=1.1928 loss_corrupt=2.2172 acc_corrupt_t_0p0_0p2=0.2299 corrupt_frac_t_0p0_0p2=0.1494 acc_corrupt_t_0p2_0p4=0.4086 corrupt_frac_t_0p2_0p4=0.0879 acc_corrupt_t_0p4_0p6=0.6152 corrupt_frac_t_0p4_0p6=0.2171 acc_corrupt_t_0p6_0p8=0.7794 corrupt_frac_t_0p6_0p8=0.3014 acc_corrupt_t_0p8_1p0=0.9466 corrupt_frac_t_0p8_1p0=0.2442 wrong_frac=0.3962 init_acc_corrupt=0.5802 init_gold_top10=0.6193 init_gold_top100=0.7377 rollout_applied_pos_frac=0.6446 init_acc_rollout_applied=0.6091 init_acc_rollout_kept=0.5278 logit_acc_rollout_applied=0.6843 logit_acc_rollout_kept=0.6436 +step=3050 micro_steps=12200 elapsed=264.8s lr=2.000000e-03 loss=2.9579 loss_recon=2.9579 loss_meanflow=0.0000 mean_model_t=0.4957 mean_corrupt_t=0.4957 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5200 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.3798 out_g_norm=0.8485 acc_all=0.8081 acc_corrupt=0.6381 corrupt_frac=0.5101 loss_all=1.2915 loss_corrupt=2.4090 acc_corrupt_t_0p0_0p2=0.2148 corrupt_frac_t_0p0_0p2=0.1688 acc_corrupt_t_0p2_0p4=0.3965 corrupt_frac_t_0p2_0p4=0.0963 acc_corrupt_t_0p4_0p6=0.6175 corrupt_frac_t_0p4_0p6=0.2633 acc_corrupt_t_0p6_0p8=0.7935 corrupt_frac_t_0p6_0p8=0.2468 acc_corrupt_t_0p8_1p0=0.9127 corrupt_frac_t_0p8_1p0=0.2249 wrong_frac=0.4341 init_acc_corrupt=0.5407 init_gold_top10=0.5850 init_gold_top100=0.7320 rollout_applied_pos_frac=0.6130 init_acc_rollout_applied=0.5204 init_acc_rollout_kept=0.5730 logit_acc_rollout_applied=0.6126 logit_acc_rollout_kept=0.6784 +step=3100 micro_steps=12400 elapsed=261.3s lr=2.000000e-03 loss=3.0007 loss_recon=3.0007 loss_meanflow=0.0000 mean_model_t=0.4850 mean_corrupt_t=0.4850 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5094 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.5043 out_g_norm=0.8128 acc_all=0.8020 acc_corrupt=0.6754 corrupt_frac=0.5917 loss_all=1.3565 loss_corrupt=2.2112 acc_corrupt_t_0p0_0p2=0.2144 corrupt_frac_t_0p0_0p2=0.1080 acc_corrupt_t_0p2_0p4=0.3154 corrupt_frac_t_0p2_0p4=0.1527 acc_corrupt_t_0p4_0p6=0.6586 corrupt_frac_t_0p4_0p6=0.1565 acc_corrupt_t_0p6_0p8=0.7705 corrupt_frac_t_0p6_0p8=0.2355 acc_corrupt_t_0p8_1p0=0.9202 corrupt_frac_t_0p8_1p0=0.3472 wrong_frac=0.3883 init_acc_corrupt=0.5829 init_gold_top10=0.6249 init_gold_top100=0.7268 rollout_applied_pos_frac=0.4543 init_acc_rollout_applied=0.5595 init_acc_rollout_kept=0.6024 logit_acc_rollout_applied=0.6527 logit_acc_rollout_kept=0.6943 +step=3150 micro_steps=12600 elapsed=263.2s lr=2.000000e-03 loss=2.8584 loss_recon=2.8584 loss_meanflow=0.0000 mean_model_t=0.5120 mean_corrupt_t=0.5120 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5006 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.6278 out_g_norm=0.8110 acc_all=0.7011 acc_corrupt=0.5568 corrupt_frac=0.6590 loss_all=2.0513 loss_corrupt=3.0269 acc_corrupt_t_0p0_0p2=0.1538 corrupt_frac_t_0p0_0p2=0.1517 acc_corrupt_t_0p2_0p4=0.3604 corrupt_frac_t_0p2_0p4=0.1945 acc_corrupt_t_0p4_0p6=0.5954 corrupt_frac_t_0p4_0p6=0.2686 acc_corrupt_t_0p6_0p8=0.7803 corrupt_frac_t_0p6_0p8=0.3387 acc_corrupt_t_0p8_1p0=0.8435 corrupt_frac_t_0p8_1p0=0.0464 wrong_frac=0.5171 init_acc_corrupt=0.4543 init_gold_top10=0.4891 init_gold_top100=0.5930 rollout_applied_pos_frac=0.3054 init_acc_rollout_applied=0.3986 init_acc_rollout_kept=0.4788 logit_acc_rollout_applied=0.4987 logit_acc_rollout_kept=0.5824 +step=3200 micro_steps=12800 elapsed=263.9s lr=2.000000e-03 loss=2.8683 loss_recon=2.8683 loss_meanflow=0.0000 mean_model_t=0.5081 mean_corrupt_t=0.5081 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5062 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.7482 out_g_norm=0.8158 acc_all=0.7468 acc_corrupt=0.5169 corrupt_frac=0.5128 loss_all=1.8022 loss_corrupt=3.4096 acc_corrupt_t_0p0_0p2=0.1375 corrupt_frac_t_0p0_0p2=0.2307 acc_corrupt_t_0p2_0p4=0.3087 corrupt_frac_t_0p2_0p4=0.2597 acc_corrupt_t_0p4_0p6=0.6118 corrupt_frac_t_0p4_0p6=0.0817 acc_corrupt_t_0p6_0p8=0.7555 corrupt_frac_t_0p6_0p8=0.2675 acc_corrupt_t_0p8_1p0=0.9536 corrupt_frac_t_0p8_1p0=0.1604 wrong_frac=0.5357 init_acc_corrupt=0.4104 init_gold_top10=0.4669 init_gold_top100=0.5887 rollout_applied_pos_frac=0.4249 init_acc_rollout_applied=0.4800 init_acc_rollout_kept=0.3590 logit_acc_rollout_applied=0.5638 logit_acc_rollout_kept=0.4823 +step=3250 micro_steps=13000 elapsed=262.9s lr=2.000000e-03 loss=2.9173 loss_recon=2.9173 loss_meanflow=0.0000 mean_model_t=0.4984 mean_corrupt_t=0.4984 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4925 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.8701 out_g_norm=0.7803 acc_all=0.7892 acc_corrupt=0.6549 corrupt_frac=0.5976 loss_all=1.4040 loss_corrupt=2.2767 acc_corrupt_t_0p0_0p2=0.2328 corrupt_frac_t_0p0_0p2=0.1042 acc_corrupt_t_0p2_0p4=0.3850 corrupt_frac_t_0p2_0p4=0.1792 acc_corrupt_t_0p4_0p6=0.5717 corrupt_frac_t_0p4_0p6=0.1681 acc_corrupt_t_0p6_0p8=0.7687 corrupt_frac_t_0p6_0p8=0.2356 acc_corrupt_t_0p8_1p0=0.9089 corrupt_frac_t_0p8_1p0=0.3129 wrong_frac=0.4162 init_acc_corrupt=0.5548 init_gold_top10=0.5953 init_gold_top100=0.7169 rollout_applied_pos_frac=0.4550 init_acc_rollout_applied=0.5211 init_acc_rollout_kept=0.5829 logit_acc_rollout_applied=0.6364 logit_acc_rollout_kept=0.6704 +step=3300 micro_steps=13200 elapsed=263.1s lr=2.000000e-03 loss=2.8192 loss_recon=2.8192 loss_meanflow=0.0000 mean_model_t=0.5076 mean_corrupt_t=0.5076 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5012 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=23.9882 out_g_norm=0.7938 acc_all=0.7934 acc_corrupt=0.6399 corrupt_frac=0.5573 loss_all=1.4256 loss_corrupt=2.4616 acc_corrupt_t_0p0_0p2=0.2001 corrupt_frac_t_0p0_0p2=0.1730 acc_corrupt_t_0p2_0p4=0.4338 corrupt_frac_t_0p2_0p4=0.0525 acc_corrupt_t_0p4_0p6=0.5801 corrupt_frac_t_0p4_0p6=0.2530 acc_corrupt_t_0p6_0p8=0.7319 corrupt_frac_t_0p6_0p8=0.2641 acc_corrupt_t_0p8_1p0=0.9421 corrupt_frac_t_0p8_1p0=0.2574 wrong_frac=0.4321 init_acc_corrupt=0.5489 init_gold_top10=0.5870 init_gold_top100=0.6869 rollout_applied_pos_frac=0.4310 init_acc_rollout_applied=0.5842 init_acc_rollout_kept=0.5222 logit_acc_rollout_applied=0.6715 logit_acc_rollout_kept=0.6160 +step=3350 micro_steps=13400 elapsed=273.6s lr=2.000000e-03 loss=2.9373 loss_recon=2.9373 loss_meanflow=0.0000 mean_model_t=0.4988 mean_corrupt_t=0.4988 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4919 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.1074 out_g_norm=0.7882 acc_all=0.7285 acc_corrupt=0.4955 corrupt_frac=0.5280 loss_all=1.9183 loss_corrupt=3.5447 acc_corrupt_t_0p0_0p2=0.1530 corrupt_frac_t_0p0_0p2=0.1761 acc_corrupt_t_0p2_0p4=0.4239 corrupt_frac_t_0p2_0p4=0.3183 acc_corrupt_t_0p4_0p6=0.5493 corrupt_frac_t_0p4_0p6=0.3041 acc_corrupt_t_0p6_0p8=0.7987 corrupt_frac_t_0p6_0p8=0.1404 acc_corrupt_t_0p8_1p0=0.8913 corrupt_frac_t_0p8_1p0=0.0612 wrong_frac=0.5805 init_acc_corrupt=0.3857 init_gold_top10=0.4262 init_gold_top100=0.6229 rollout_applied_pos_frac=0.6401 init_acc_rollout_applied=0.4032 init_acc_rollout_kept=0.3544 logit_acc_rollout_applied=0.5084 logit_acc_rollout_kept=0.4728 +step=3400 micro_steps=13600 elapsed=276.2s lr=2.000000e-03 loss=2.9448 loss_recon=2.9448 loss_meanflow=0.0000 mean_model_t=0.4870 mean_corrupt_t=0.4870 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5331 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.2247 out_g_norm=0.8219 acc_all=0.7580 acc_corrupt=0.5268 corrupt_frac=0.4902 loss_all=1.5977 loss_corrupt=3.0962 acc_corrupt_t_0p0_0p2=0.2053 corrupt_frac_t_0p0_0p2=0.3894 acc_corrupt_t_0p2_0p4=0.4675 corrupt_frac_t_0p2_0p4=0.1178 acc_corrupt_t_0p4_0p6=0.6580 corrupt_frac_t_0p4_0p6=0.1347 acc_corrupt_t_0p6_0p8=0.7183 corrupt_frac_t_0p6_0p8=0.1335 acc_corrupt_t_0p8_1p0=0.9229 corrupt_frac_t_0p8_1p0=0.2246 wrong_frac=0.5607 init_acc_corrupt=0.3977 init_gold_top10=0.4465 init_gold_top100=0.6203 rollout_applied_pos_frac=0.5002 init_acc_rollout_applied=0.4214 init_acc_rollout_kept=0.3740 logit_acc_rollout_applied=0.5357 logit_acc_rollout_kept=0.5180 +step=3450 micro_steps=13800 elapsed=276.9s lr=2.000000e-03 loss=2.9051 loss_recon=2.9051 loss_meanflow=0.0000 mean_model_t=0.4930 mean_corrupt_t=0.4930 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4906 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.3404 out_g_norm=0.7789 acc_all=0.8129 acc_corrupt=0.6554 corrupt_frac=0.5285 loss_all=1.2605 loss_corrupt=2.3041 acc_corrupt_t_0p0_0p2=0.2213 corrupt_frac_t_0p0_0p2=0.1657 acc_corrupt_t_0p2_0p4=0.4339 corrupt_frac_t_0p2_0p4=0.1590 acc_corrupt_t_0p4_0p6=0.5756 corrupt_frac_t_0p4_0p6=0.1207 acc_corrupt_t_0p6_0p8=0.7996 corrupt_frac_t_0p6_0p8=0.1706 acc_corrupt_t_0p8_1p0=0.8955 corrupt_frac_t_0p8_1p0=0.3841 wrong_frac=0.4222 init_acc_corrupt=0.5561 init_gold_top10=0.6005 init_gold_top100=0.7097 rollout_applied_pos_frac=0.4690 init_acc_rollout_applied=0.5462 init_acc_rollout_kept=0.5649 logit_acc_rollout_applied=0.6439 logit_acc_rollout_kept=0.6656 +step=3500 micro_steps=14000 elapsed=277.5s lr=2.000000e-03 loss=2.8547 loss_recon=2.8547 loss_meanflow=0.0000 mean_model_t=0.4981 mean_corrupt_t=0.4981 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5088 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.4546 out_g_norm=0.7536 acc_all=0.8140 acc_corrupt=0.6718 corrupt_frac=0.5497 loss_all=1.2588 loss_corrupt=2.1983 acc_corrupt_t_0p0_0p2=0.2076 corrupt_frac_t_0p0_0p2=0.2313 acc_corrupt_t_0p2_0p4=0.3908 corrupt_frac_t_0p2_0p4=0.0788 acc_corrupt_t_0p4_0p6=0.5876 corrupt_frac_t_0p4_0p6=0.0897 acc_corrupt_t_0p6_0p8=0.7733 corrupt_frac_t_0p6_0p8=0.1660 acc_corrupt_t_0p8_1p0=0.9486 corrupt_frac_t_0p8_1p0=0.4342 wrong_frac=0.3948 init_acc_corrupt=0.5794 init_gold_top10=0.6201 init_gold_top100=0.7449 rollout_applied_pos_frac=0.4869 init_acc_rollout_applied=0.5183 init_acc_rollout_kept=0.6373 logit_acc_rollout_applied=0.6169 logit_acc_rollout_kept=0.7239 +step=3550 micro_steps=14200 elapsed=279.2s lr=2.000000e-03 loss=2.8112 loss_recon=2.8112 loss_meanflow=0.0000 mean_model_t=0.5062 mean_corrupt_t=0.5062 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5131 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.5672 out_g_norm=0.7685 acc_all=0.7552 acc_corrupt=0.5603 corrupt_frac=0.5420 loss_all=1.6511 loss_corrupt=2.9371 acc_corrupt_t_0p0_0p2=0.2018 corrupt_frac_t_0p0_0p2=0.2145 acc_corrupt_t_0p2_0p4=0.2979 corrupt_frac_t_0p2_0p4=0.1552 acc_corrupt_t_0p4_0p6=0.5799 corrupt_frac_t_0p4_0p6=0.2505 acc_corrupt_t_0p6_0p8=0.7965 corrupt_frac_t_0p6_0p8=0.2087 acc_corrupt_t_0p8_1p0=0.9309 corrupt_frac_t_0p8_1p0=0.1712 wrong_frac=0.5278 init_acc_corrupt=0.4363 init_gold_top10=0.5012 init_gold_top100=0.6654 rollout_applied_pos_frac=0.5214 init_acc_rollout_applied=0.4017 init_acc_rollout_kept=0.4741 logit_acc_rollout_applied=0.5238 logit_acc_rollout_kept=0.6001 +step=3600 micro_steps=14400 elapsed=277.7s lr=2.000000e-03 loss=2.7533 loss_recon=2.7533 loss_meanflow=0.0000 mean_model_t=0.5171 mean_corrupt_t=0.5171 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5075 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.6802 out_g_norm=0.7618 acc_all=0.7715 acc_corrupt=0.6196 corrupt_frac=0.5917 loss_all=1.5511 loss_corrupt=2.5661 acc_corrupt_t_0p0_0p2=0.1894 corrupt_frac_t_0p0_0p2=0.0732 acc_corrupt_t_0p2_0p4=0.3384 corrupt_frac_t_0p2_0p4=0.2291 acc_corrupt_t_0p4_0p6=0.6185 corrupt_frac_t_0p4_0p6=0.2673 acc_corrupt_t_0p6_0p8=0.7729 corrupt_frac_t_0p6_0p8=0.2691 acc_corrupt_t_0p8_1p0=0.9607 corrupt_frac_t_0p8_1p0=0.1613 wrong_frac=0.4527 init_acc_corrupt=0.5132 init_gold_top10=0.5561 init_gold_top100=0.6811 rollout_applied_pos_frac=0.4772 init_acc_rollout_applied=0.5024 init_acc_rollout_kept=0.5230 logit_acc_rollout_applied=0.6081 logit_acc_rollout_kept=0.6302 +step=3650 micro_steps=14600 elapsed=271.1s lr=2.000000e-03 loss=2.8056 loss_recon=2.8056 loss_meanflow=0.0000 mean_model_t=0.5100 mean_corrupt_t=0.5100 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4963 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.7929 out_g_norm=0.7609 acc_all=0.7983 acc_corrupt=0.6315 corrupt_frac=0.5359 loss_all=1.3906 loss_corrupt=2.5279 acc_corrupt_t_0p0_0p2=0.1864 corrupt_frac_t_0p0_0p2=0.0868 acc_corrupt_t_0p2_0p4=0.4081 corrupt_frac_t_0p2_0p4=0.3530 acc_corrupt_t_0p4_0p6=0.5645 corrupt_frac_t_0p4_0p6=0.0901 acc_corrupt_t_0p6_0p8=0.8211 corrupt_frac_t_0p6_0p8=0.1155 acc_corrupt_t_0p8_1p0=0.9182 corrupt_frac_t_0p8_1p0=0.3546 wrong_frac=0.4400 init_acc_corrupt=0.5298 init_gold_top10=0.5762 init_gold_top100=0.7099 rollout_applied_pos_frac=0.5145 init_acc_rollout_applied=0.5055 init_acc_rollout_kept=0.5555 logit_acc_rollout_applied=0.6145 logit_acc_rollout_kept=0.6496 +step=3700 micro_steps=14800 elapsed=264.8s lr=2.000000e-03 loss=2.8558 loss_recon=2.8558 loss_meanflow=0.0000 mean_model_t=0.4986 mean_corrupt_t=0.4986 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5125 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=24.9048 out_g_norm=0.7362 acc_all=0.7135 acc_corrupt=0.5407 corrupt_frac=0.6103 loss_all=1.9588 loss_corrupt=3.1239 acc_corrupt_t_0p0_0p2=0.1662 corrupt_frac_t_0p0_0p2=0.2465 acc_corrupt_t_0p2_0p4=0.3000 corrupt_frac_t_0p2_0p4=0.1754 acc_corrupt_t_0p4_0p6=0.5752 corrupt_frac_t_0p4_0p6=0.2015 acc_corrupt_t_0p6_0p8=0.8206 corrupt_frac_t_0p6_0p8=0.1717 acc_corrupt_t_0p8_1p0=0.9285 corrupt_frac_t_0p8_1p0=0.2049 wrong_frac=0.5281 init_acc_corrupt=0.4303 init_gold_top10=0.4865 init_gold_top100=0.6822 rollout_applied_pos_frac=0.5245 init_acc_rollout_applied=0.3037 init_acc_rollout_kept=0.5700 logit_acc_rollout_applied=0.4296 logit_acc_rollout_kept=0.6631 +step=3750 micro_steps=15000 elapsed=264.1s lr=2.000000e-03 loss=2.7932 loss_recon=2.7932 loss_meanflow=0.0000 mean_model_t=0.5049 mean_corrupt_t=0.5049 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4856 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.0137 out_g_norm=0.7435 acc_all=0.8133 acc_corrupt=0.6209 corrupt_frac=0.4803 loss_all=1.2664 loss_corrupt=2.5485 acc_corrupt_t_0p0_0p2=0.1654 corrupt_frac_t_0p0_0p2=0.1702 acc_corrupt_t_0p2_0p4=0.4396 corrupt_frac_t_0p2_0p4=0.1841 acc_corrupt_t_0p4_0p6=0.5845 corrupt_frac_t_0p4_0p6=0.1808 acc_corrupt_t_0p6_0p8=0.8219 corrupt_frac_t_0p6_0p8=0.2354 acc_corrupt_t_0p8_1p0=0.9267 corrupt_frac_t_0p8_1p0=0.2296 wrong_frac=0.4624 init_acc_corrupt=0.5129 init_gold_top10=0.5542 init_gold_top100=0.7153 rollout_applied_pos_frac=0.5643 init_acc_rollout_applied=0.4809 init_acc_rollout_kept=0.5543 logit_acc_rollout_applied=0.6052 logit_acc_rollout_kept=0.6414 +step=3800 micro_steps=15200 elapsed=264.0s lr=2.000000e-03 loss=2.9306 loss_recon=2.9306 loss_meanflow=0.0000 mean_model_t=0.4827 mean_corrupt_t=0.4827 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4963 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.1236 out_g_norm=0.7339 acc_all=0.7679 acc_corrupt=0.5858 corrupt_frac=0.5461 loss_all=1.5569 loss_corrupt=2.7615 acc_corrupt_t_0p0_0p2=0.1787 corrupt_frac_t_0p0_0p2=0.2060 acc_corrupt_t_0p2_0p4=0.4138 corrupt_frac_t_0p2_0p4=0.1047 acc_corrupt_t_0p4_0p6=0.6013 corrupt_frac_t_0p4_0p6=0.3686 acc_corrupt_t_0p6_0p8=0.7969 corrupt_frac_t_0p6_0p8=0.1535 acc_corrupt_t_0p8_1p0=0.9669 corrupt_frac_t_0p8_1p0=0.1672 wrong_frac=0.5029 init_acc_corrupt=0.4720 init_gold_top10=0.5122 init_gold_top100=0.6856 rollout_applied_pos_frac=0.5177 init_acc_rollout_applied=0.4084 init_acc_rollout_kept=0.5403 logit_acc_rollout_applied=0.5393 logit_acc_rollout_kept=0.6357 +step=3850 micro_steps=15400 elapsed=264.1s lr=2.000000e-03 loss=2.7769 loss_recon=2.7769 loss_meanflow=0.0000 mean_model_t=0.5093 mean_corrupt_t=0.5093 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5050 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.2322 out_g_norm=0.7328 acc_all=0.7617 acc_corrupt=0.5735 corrupt_frac=0.5516 loss_all=1.5985 loss_corrupt=2.8429 acc_corrupt_t_0p0_0p2=0.2425 corrupt_frac_t_0p0_0p2=0.0627 acc_corrupt_t_0p2_0p4=0.3009 corrupt_frac_t_0p2_0p4=0.3280 acc_corrupt_t_0p4_0p6=0.5995 corrupt_frac_t_0p4_0p6=0.2485 acc_corrupt_t_0p6_0p8=0.8096 corrupt_frac_t_0p6_0p8=0.2371 acc_corrupt_t_0p8_1p0=0.9597 corrupt_frac_t_0p8_1p0=0.1236 wrong_frac=0.5012 init_acc_corrupt=0.4546 init_gold_top10=0.5199 init_gold_top100=0.6994 rollout_applied_pos_frac=0.6465 init_acc_rollout_applied=0.4557 init_acc_rollout_kept=0.4527 logit_acc_rollout_applied=0.5745 logit_acc_rollout_kept=0.5717 +step=3900 micro_steps=15600 elapsed=264.1s lr=2.000000e-03 loss=2.7873 loss_recon=2.7873 loss_meanflow=0.0000 mean_model_t=0.4953 mean_corrupt_t=0.4953 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5169 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.3409 out_g_norm=0.7292 acc_all=0.7092 acc_corrupt=0.5279 corrupt_frac=0.6053 loss_all=1.9772 loss_corrupt=3.1896 acc_corrupt_t_0p0_0p2=0.1530 corrupt_frac_t_0p0_0p2=0.1954 acc_corrupt_t_0p2_0p4=0.3958 corrupt_frac_t_0p2_0p4=0.1820 acc_corrupt_t_0p4_0p6=0.5717 corrupt_frac_t_0p4_0p6=0.3243 acc_corrupt_t_0p6_0p8=0.7738 corrupt_frac_t_0p6_0p8=0.2363 acc_corrupt_t_0p8_1p0=0.9301 corrupt_frac_t_0p8_1p0=0.0621 wrong_frac=0.5574 init_acc_corrupt=0.4107 init_gold_top10=0.4557 init_gold_top100=0.6467 rollout_applied_pos_frac=0.5728 init_acc_rollout_applied=0.3375 init_acc_rollout_kept=0.5089 logit_acc_rollout_applied=0.4518 logit_acc_rollout_kept=0.6298 +step=3950 micro_steps=15800 elapsed=263.8s lr=2.000000e-03 loss=2.8442 loss_recon=2.8442 loss_meanflow=0.0000 mean_model_t=0.4938 mean_corrupt_t=0.4938 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4906 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.4488 out_g_norm=0.7125 acc_all=0.7883 acc_corrupt=0.6145 corrupt_frac=0.5347 loss_all=1.4258 loss_corrupt=2.5820 acc_corrupt_t_0p0_0p2=0.1896 corrupt_frac_t_0p0_0p2=0.2261 acc_corrupt_t_0p2_0p4=0.3576 corrupt_frac_t_0p2_0p4=0.1836 acc_corrupt_t_0p4_0p6=0.6542 corrupt_frac_t_0p4_0p6=0.1114 acc_corrupt_t_0p6_0p8=0.8128 corrupt_frac_t_0p6_0p8=0.1098 acc_corrupt_t_0p8_1p0=0.9315 corrupt_frac_t_0p8_1p0=0.3692 wrong_frac=0.4588 init_acc_corrupt=0.5009 init_gold_top10=0.5593 init_gold_top100=0.6928 rollout_applied_pos_frac=0.5310 init_acc_rollout_applied=0.6079 init_acc_rollout_kept=0.3798 logit_acc_rollout_applied=0.7048 logit_acc_rollout_kept=0.5122 +step=4000 micro_steps=16000 elapsed=263.9s lr=2.000000e-03 loss=2.8274 loss_recon=2.8274 loss_meanflow=0.0000 mean_model_t=0.4916 mean_corrupt_t=0.4916 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5056 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.5555 out_g_norm=0.7078 acc_all=0.7777 acc_corrupt=0.5745 corrupt_frac=0.5133 loss_all=1.4905 loss_corrupt=2.8298 acc_corrupt_t_0p0_0p2=0.1767 corrupt_frac_t_0p0_0p2=0.1722 acc_corrupt_t_0p2_0p4=0.4218 corrupt_frac_t_0p2_0p4=0.1965 acc_corrupt_t_0p4_0p6=0.5936 corrupt_frac_t_0p4_0p6=0.2705 acc_corrupt_t_0p6_0p8=0.8113 corrupt_frac_t_0p6_0p8=0.2618 acc_corrupt_t_0p8_1p0=0.8913 corrupt_frac_t_0p8_1p0=0.0990 wrong_frac=0.5158 init_acc_corrupt=0.4503 init_gold_top10=0.5016 init_gold_top100=0.6922 rollout_applied_pos_frac=0.6482 init_acc_rollout_applied=0.4203 init_acc_rollout_kept=0.5055 logit_acc_rollout_applied=0.5418 logit_acc_rollout_kept=0.6348 +step=4050 micro_steps=16200 elapsed=268.0s lr=2.000000e-03 loss=2.8548 loss_recon=2.8548 loss_meanflow=0.0000 mean_model_t=0.4929 mean_corrupt_t=0.4929 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4856 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.6615 out_g_norm=0.7216 acc_all=0.7355 acc_corrupt=0.5769 corrupt_frac=0.6184 loss_all=1.8262 loss_corrupt=2.9043 acc_corrupt_t_0p0_0p2=0.1358 corrupt_frac_t_0p0_0p2=0.2514 acc_corrupt_t_0p2_0p4=0.4568 corrupt_frac_t_0p2_0p4=0.1182 acc_corrupt_t_0p4_0p6=0.6200 corrupt_frac_t_0p4_0p6=0.2527 acc_corrupt_t_0p6_0p8=0.7958 corrupt_frac_t_0p6_0p8=0.1559 acc_corrupt_t_0p8_1p0=0.9379 corrupt_frac_t_0p8_1p0=0.2218 wrong_frac=0.4985 init_acc_corrupt=0.4771 init_gold_top10=0.5108 init_gold_top100=0.6508 rollout_applied_pos_frac=0.5173 init_acc_rollout_applied=0.5159 init_acc_rollout_kept=0.4354 logit_acc_rollout_applied=0.6178 logit_acc_rollout_kept=0.5330 +step=4100 micro_steps=16400 elapsed=263.3s lr=2.000000e-03 loss=2.7947 loss_recon=2.7947 loss_meanflow=0.0000 mean_model_t=0.4985 mean_corrupt_t=0.4985 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4881 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.7681 out_g_norm=0.7086 acc_all=0.7282 acc_corrupt=0.5316 corrupt_frac=0.5717 loss_all=1.8223 loss_corrupt=3.1225 acc_corrupt_t_0p0_0p2=0.1409 corrupt_frac_t_0p0_0p2=0.2769 acc_corrupt_t_0p2_0p4=0.4077 corrupt_frac_t_0p2_0p4=0.1960 acc_corrupt_t_0p4_0p6=0.6013 corrupt_frac_t_0p4_0p6=0.1431 acc_corrupt_t_0p6_0p8=0.7833 corrupt_frac_t_0p6_0p8=0.1931 acc_corrupt_t_0p8_1p0=0.9186 corrupt_frac_t_0p8_1p0=0.1909 wrong_frac=0.5382 init_acc_corrupt=0.4188 init_gold_top10=0.4760 init_gold_top100=0.6349 rollout_applied_pos_frac=0.5148 init_acc_rollout_applied=0.4671 init_acc_rollout_kept=0.3675 logit_acc_rollout_applied=0.5745 logit_acc_rollout_kept=0.4860 +step=4150 micro_steps=16600 elapsed=263.1s lr=2.000000e-03 loss=2.7063 loss_recon=2.7063 loss_meanflow=0.0000 mean_model_t=0.5047 mean_corrupt_t=0.5047 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.8737 out_g_norm=0.7293 acc_all=0.7828 acc_corrupt=0.6335 corrupt_frac=0.5814 loss_all=1.4250 loss_corrupt=2.3878 acc_corrupt_t_0p0_0p2=0.2372 corrupt_frac_t_0p0_0p2=0.1113 acc_corrupt_t_0p2_0p4=0.4381 corrupt_frac_t_0p2_0p4=0.2305 acc_corrupt_t_0p4_0p6=0.6179 corrupt_frac_t_0p4_0p6=0.2700 acc_corrupt_t_0p6_0p8=0.7898 corrupt_frac_t_0p6_0p8=0.1653 acc_corrupt_t_0p8_1p0=0.9364 corrupt_frac_t_0p8_1p0=0.2229 wrong_frac=0.4530 init_acc_corrupt=0.5187 init_gold_top10=0.5591 init_gold_top100=0.6411 rollout_applied_pos_frac=0.4096 init_acc_rollout_applied=0.6745 init_acc_rollout_kept=0.4105 logit_acc_rollout_applied=0.7495 logit_acc_rollout_kept=0.5529 +step=4200 micro_steps=16800 elapsed=263.3s lr=2.000000e-03 loss=2.7494 loss_recon=2.7494 loss_meanflow=0.0000 mean_model_t=0.4969 mean_corrupt_t=0.4969 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4988 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=25.9771 out_g_norm=0.6942 acc_all=0.7697 acc_corrupt=0.5724 corrupt_frac=0.5312 loss_all=1.5580 loss_corrupt=2.8668 acc_corrupt_t_0p0_0p2=0.1634 corrupt_frac_t_0p0_0p2=0.2243 acc_corrupt_t_0p2_0p4=0.3960 corrupt_frac_t_0p2_0p4=0.1959 acc_corrupt_t_0p4_0p6=0.6381 corrupt_frac_t_0p4_0p6=0.1581 acc_corrupt_t_0p6_0p8=0.7741 corrupt_frac_t_0p6_0p8=0.2569 acc_corrupt_t_0p8_1p0=0.9610 corrupt_frac_t_0p8_1p0=0.1648 wrong_frac=0.5047 init_acc_corrupt=0.4589 init_gold_top10=0.5065 init_gold_top100=0.6517 rollout_applied_pos_frac=0.5423 init_acc_rollout_applied=0.5181 init_acc_rollout_kept=0.3889 logit_acc_rollout_applied=0.6138 logit_acc_rollout_kept=0.5233 +step=4250 micro_steps=17000 elapsed=263.3s lr=2.000000e-03 loss=2.7803 loss_recon=2.7803 loss_meanflow=0.0000 mean_model_t=0.4973 mean_corrupt_t=0.4973 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4813 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.0803 out_g_norm=0.6849 acc_all=0.8151 acc_corrupt=0.6309 corrupt_frac=0.4828 loss_all=1.2145 loss_corrupt=2.4109 acc_corrupt_t_0p0_0p2=0.1875 corrupt_frac_t_0p0_0p2=0.2107 acc_corrupt_t_0p2_0p4=0.3094 corrupt_frac_t_0p2_0p4=0.0739 acc_corrupt_t_0p4_0p6=0.6412 corrupt_frac_t_0p4_0p6=0.1173 acc_corrupt_t_0p6_0p8=0.7816 corrupt_frac_t_0p6_0p8=0.4151 acc_corrupt_t_0p8_1p0=0.9227 corrupt_frac_t_0p8_1p0=0.1830 wrong_frac=0.4611 init_acc_corrupt=0.5174 init_gold_top10=0.5652 init_gold_top100=0.6711 rollout_applied_pos_frac=0.4093 init_acc_rollout_applied=0.4991 init_acc_rollout_kept=0.5301 logit_acc_rollout_applied=0.6135 logit_acc_rollout_kept=0.6429 +step=4300 micro_steps=17200 elapsed=263.3s lr=2.000000e-03 loss=2.7268 loss_recon=2.7268 loss_meanflow=0.0000 mean_model_t=0.5007 mean_corrupt_t=0.5007 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5056 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.1847 out_g_norm=0.7289 acc_all=0.7867 acc_corrupt=0.6193 corrupt_frac=0.5516 loss_all=1.3976 loss_corrupt=2.4716 acc_corrupt_t_0p0_0p2=0.2428 corrupt_frac_t_0p0_0p2=0.1149 acc_corrupt_t_0p2_0p4=0.3696 corrupt_frac_t_0p2_0p4=0.2328 acc_corrupt_t_0p4_0p6=0.6335 corrupt_frac_t_0p4_0p6=0.1819 acc_corrupt_t_0p6_0p8=0.7615 corrupt_frac_t_0p6_0p8=0.2865 acc_corrupt_t_0p8_1p0=0.9347 corrupt_frac_t_0p8_1p0=0.1839 wrong_frac=0.4635 init_acc_corrupt=0.5049 init_gold_top10=0.5502 init_gold_top100=0.6800 rollout_applied_pos_frac=0.4337 init_acc_rollout_applied=0.4342 init_acc_rollout_kept=0.5590 logit_acc_rollout_applied=0.5637 logit_acc_rollout_kept=0.6618 +step=4350 micro_steps=17400 elapsed=263.4s lr=2.000000e-03 loss=2.7159 loss_recon=2.7159 loss_meanflow=0.0000 mean_model_t=0.5040 mean_corrupt_t=0.5040 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5225 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.2873 out_g_norm=0.6898 acc_all=0.7430 acc_corrupt=0.5758 corrupt_frac=0.5936 loss_all=1.6647 loss_corrupt=2.7235 acc_corrupt_t_0p0_0p2=0.1990 corrupt_frac_t_0p0_0p2=0.2166 acc_corrupt_t_0p2_0p4=0.4440 corrupt_frac_t_0p2_0p4=0.2736 acc_corrupt_t_0p4_0p6=0.6281 corrupt_frac_t_0p4_0p6=0.1917 acc_corrupt_t_0p6_0p8=0.8139 corrupt_frac_t_0p6_0p8=0.0356 acc_corrupt_t_0p8_1p0=0.9270 corrupt_frac_t_0p8_1p0=0.2825 wrong_frac=0.5105 init_acc_corrupt=0.4502 init_gold_top10=0.5070 init_gold_top100=0.7311 rollout_applied_pos_frac=0.6488 init_acc_rollout_applied=0.3746 init_acc_rollout_kept=0.5900 logit_acc_rollout_applied=0.5063 logit_acc_rollout_kept=0.7043 +step=4400 micro_steps=17600 elapsed=263.4s lr=2.000000e-03 loss=2.6621 loss_recon=2.6621 loss_meanflow=0.0000 mean_model_t=0.5036 mean_corrupt_t=0.5036 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5038 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.3901 out_g_norm=0.7013 acc_all=0.8082 acc_corrupt=0.6906 corrupt_frac=0.6130 loss_all=1.2912 loss_corrupt=2.0746 acc_corrupt_t_0p0_0p2=0.2011 corrupt_frac_t_0p0_0p2=0.0661 acc_corrupt_t_0p2_0p4=0.3510 corrupt_frac_t_0p2_0p4=0.1624 acc_corrupt_t_0p4_0p6=0.5860 corrupt_frac_t_0p4_0p6=0.2180 acc_corrupt_t_0p6_0p8=0.8137 corrupt_frac_t_0p6_0p8=0.2354 acc_corrupt_t_0p8_1p0=0.9463 corrupt_frac_t_0p8_1p0=0.3181 wrong_frac=0.3821 init_acc_corrupt=0.5943 init_gold_top10=0.6451 init_gold_top100=0.7929 rollout_applied_pos_frac=0.6697 init_acc_rollout_applied=0.5592 init_acc_rollout_kept=0.6655 logit_acc_rollout_applied=0.6676 logit_acc_rollout_kept=0.7371 +step=4450 micro_steps=17800 elapsed=263.9s lr=2.000000e-03 loss=2.7425 loss_recon=2.7425 loss_meanflow=0.0000 mean_model_t=0.5002 mean_corrupt_t=0.5002 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5162 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.4923 out_g_norm=0.6740 acc_all=0.7343 acc_corrupt=0.4962 corrupt_frac=0.5198 loss_all=1.7948 loss_corrupt=3.3830 acc_corrupt_t_0p0_0p2=0.2282 corrupt_frac_t_0p0_0p2=0.1950 acc_corrupt_t_0p2_0p4=0.3700 corrupt_frac_t_0p2_0p4=0.4387 acc_corrupt_t_0p4_0p6=0.6460 corrupt_frac_t_0p4_0p6=0.1249 acc_corrupt_t_0p6_0p8=0.7686 corrupt_frac_t_0p6_0p8=0.0885 acc_corrupt_t_0p8_1p0=0.9201 corrupt_frac_t_0p8_1p0=0.1528 wrong_frac=0.5948 init_acc_corrupt=0.3445 init_gold_top10=0.4198 init_gold_top100=0.6101 rollout_applied_pos_frac=0.5157 init_acc_rollout_applied=0.3260 init_acc_rollout_kept=0.3641 logit_acc_rollout_applied=0.4867 logit_acc_rollout_kept=0.5063 +step=4500 micro_steps=18000 elapsed=264.0s lr=2.000000e-03 loss=2.7535 loss_recon=2.7535 loss_meanflow=0.0000 mean_model_t=0.5042 mean_corrupt_t=0.5042 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4881 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.5949 out_g_norm=0.7023 acc_all=0.7549 acc_corrupt=0.5508 corrupt_frac=0.5353 loss_all=1.6501 loss_corrupt=2.9984 acc_corrupt_t_0p0_0p2=0.1866 corrupt_frac_t_0p0_0p2=0.4039 acc_corrupt_t_0p2_0p4=0.2505 corrupt_frac_t_0p2_0p4=0.0931 acc_corrupt_t_0p4_0p6=0.7053 corrupt_frac_t_0p4_0p6=0.0698 acc_corrupt_t_0p6_0p8=0.8303 corrupt_frac_t_0p6_0p8=0.0474 acc_corrupt_t_0p8_1p0=0.9422 corrupt_frac_t_0p8_1p0=0.3858 wrong_frac=0.5082 init_acc_corrupt=0.4442 init_gold_top10=0.5141 init_gold_top100=0.7182 rollout_applied_pos_frac=0.6736 init_acc_rollout_applied=0.4433 init_acc_rollout_kept=0.4461 logit_acc_rollout_applied=0.5305 logit_acc_rollout_kept=0.5928 +step=4550 micro_steps=18200 elapsed=266.9s lr=2.000000e-03 loss=2.6974 loss_recon=2.6974 loss_meanflow=0.0000 mean_model_t=0.5032 mean_corrupt_t=0.5032 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4950 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.6960 out_g_norm=0.6763 acc_all=0.7524 acc_corrupt=0.5658 corrupt_frac=0.5638 loss_all=1.6514 loss_corrupt=2.8789 acc_corrupt_t_0p0_0p2=0.2061 corrupt_frac_t_0p0_0p2=0.1660 acc_corrupt_t_0p2_0p4=0.3679 corrupt_frac_t_0p2_0p4=0.2794 acc_corrupt_t_0p4_0p6=0.5875 corrupt_frac_t_0p4_0p6=0.1573 acc_corrupt_t_0p6_0p8=0.8067 corrupt_frac_t_0p6_0p8=0.2624 acc_corrupt_t_0p8_1p0=0.9242 corrupt_frac_t_0p8_1p0=0.1349 wrong_frac=0.5178 init_acc_corrupt=0.4326 init_gold_top10=0.5026 init_gold_top100=0.6394 rollout_applied_pos_frac=0.5449 init_acc_rollout_applied=0.5365 init_acc_rollout_kept=0.3083 logit_acc_rollout_applied=0.6452 logit_acc_rollout_kept=0.4707 +step=4600 micro_steps=18400 elapsed=264.2s lr=2.000000e-03 loss=2.7505 loss_recon=2.7505 loss_meanflow=0.0000 mean_model_t=0.4884 mean_corrupt_t=0.4884 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4888 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.7962 out_g_norm=0.6707 acc_all=0.8292 acc_corrupt=0.6689 corrupt_frac=0.5056 loss_all=1.1074 loss_corrupt=2.1314 acc_corrupt_t_0p0_0p2=0.1677 corrupt_frac_t_0p0_0p2=0.1120 acc_corrupt_t_0p2_0p4=0.4681 corrupt_frac_t_0p2_0p4=0.1667 acc_corrupt_t_0p4_0p6=0.6305 corrupt_frac_t_0p4_0p6=0.2251 acc_corrupt_t_0p6_0p8=0.8032 corrupt_frac_t_0p6_0p8=0.2810 acc_corrupt_t_0p8_1p0=0.9501 corrupt_frac_t_0p8_1p0=0.2152 wrong_frac=0.4215 init_acc_corrupt=0.5595 init_gold_top10=0.6031 init_gold_top100=0.7512 rollout_applied_pos_frac=0.5470 init_acc_rollout_applied=0.4902 init_acc_rollout_kept=0.6433 logit_acc_rollout_applied=0.6183 logit_acc_rollout_kept=0.7300 +step=4650 micro_steps=18600 elapsed=266.3s lr=2.000000e-03 loss=2.6833 loss_recon=2.6833 loss_meanflow=0.0000 mean_model_t=0.5009 mean_corrupt_t=0.5009 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5025 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.8960 out_g_norm=0.6649 acc_all=0.7830 acc_corrupt=0.6138 corrupt_frac=0.5490 loss_all=1.4066 loss_corrupt=2.4776 acc_corrupt_t_0p0_0p2=0.2334 corrupt_frac_t_0p0_0p2=0.2151 acc_corrupt_t_0p2_0p4=0.3321 corrupt_frac_t_0p2_0p4=0.2047 acc_corrupt_t_0p4_0p6=0.6502 corrupt_frac_t_0p4_0p6=0.0855 acc_corrupt_t_0p6_0p8=0.7523 corrupt_frac_t_0p6_0p8=0.0848 acc_corrupt_t_0p8_1p0=0.9179 corrupt_frac_t_0p8_1p0=0.4098 wrong_frac=0.4760 init_acc_corrupt=0.4875 init_gold_top10=0.5544 init_gold_top100=0.6793 rollout_applied_pos_frac=0.6422 init_acc_rollout_applied=0.6470 init_acc_rollout_kept=0.2012 logit_acc_rollout_applied=0.7436 logit_acc_rollout_kept=0.3809 +step=4700 micro_steps=18800 elapsed=276.5s lr=2.000000e-03 loss=2.7124 loss_recon=2.7124 loss_meanflow=0.0000 mean_model_t=0.4958 mean_corrupt_t=0.4958 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4950 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=26.9948 out_g_norm=0.6553 acc_all=0.7881 acc_corrupt=0.6145 corrupt_frac=0.5356 loss_all=1.4239 loss_corrupt=2.5700 acc_corrupt_t_0p0_0p2=0.2245 corrupt_frac_t_0p0_0p2=0.2485 acc_corrupt_t_0p2_0p4=0.3929 corrupt_frac_t_0p2_0p4=0.1085 acc_corrupt_t_0p4_0p6=0.6046 corrupt_frac_t_0p4_0p6=0.2025 acc_corrupt_t_0p6_0p8=0.7510 corrupt_frac_t_0p6_0p8=0.1018 acc_corrupt_t_0p8_1p0=0.9366 corrupt_frac_t_0p8_1p0=0.3387 wrong_frac=0.4712 init_acc_corrupt=0.4945 init_gold_top10=0.5443 init_gold_top100=0.6848 rollout_applied_pos_frac=0.6070 init_acc_rollout_applied=0.5850 init_acc_rollout_kept=0.3548 logit_acc_rollout_applied=0.6782 logit_acc_rollout_kept=0.5162 +step=4750 micro_steps=19000 elapsed=272.4s lr=2.000000e-03 loss=2.8102 loss_recon=2.8102 loss_meanflow=0.0000 mean_model_t=0.4958 mean_corrupt_t=0.4958 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5038 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.0948 out_g_norm=0.6748 acc_all=0.7296 acc_corrupt=0.5466 corrupt_frac=0.5863 loss_all=1.8525 loss_corrupt=3.0865 acc_corrupt_t_0p0_0p2=0.2154 corrupt_frac_t_0p0_0p2=0.1935 acc_corrupt_t_0p2_0p4=0.3104 corrupt_frac_t_0p2_0p4=0.2825 acc_corrupt_t_0p4_0p6=0.5695 corrupt_frac_t_0p4_0p6=0.1550 acc_corrupt_t_0p6_0p8=0.7871 corrupt_frac_t_0p6_0p8=0.0860 acc_corrupt_t_0p8_1p0=0.9233 corrupt_frac_t_0p8_1p0=0.2829 wrong_frac=0.5253 init_acc_corrupt=0.4257 init_gold_top10=0.4992 init_gold_top100=0.6242 rollout_applied_pos_frac=0.3796 init_acc_rollout_applied=0.4737 init_acc_rollout_kept=0.3964 logit_acc_rollout_applied=0.6167 logit_acc_rollout_kept=0.5036 +step=4800 micro_steps=19200 elapsed=264.9s lr=2.000000e-03 loss=2.6951 loss_recon=2.6951 loss_meanflow=0.0000 mean_model_t=0.4986 mean_corrupt_t=0.4986 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5144 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.1928 out_g_norm=0.6510 acc_all=0.7617 acc_corrupt=0.5320 corrupt_frac=0.4929 loss_all=1.5717 loss_corrupt=3.0580 acc_corrupt_t_0p0_0p2=0.2385 corrupt_frac_t_0p0_0p2=0.3746 acc_corrupt_t_0p2_0p4=0.3395 corrupt_frac_t_0p2_0p4=0.1069 acc_corrupt_t_0p4_0p6=0.6228 corrupt_frac_t_0p4_0p6=0.1600 acc_corrupt_t_0p6_0p8=0.8059 corrupt_frac_t_0p6_0p8=0.2239 acc_corrupt_t_0p8_1p0=0.9379 corrupt_frac_t_0p8_1p0=0.1346 wrong_frac=0.5750 init_acc_corrupt=0.3899 init_gold_top10=0.4469 init_gold_top100=0.6326 rollout_applied_pos_frac=0.5405 init_acc_rollout_applied=0.3889 init_acc_rollout_kept=0.3911 logit_acc_rollout_applied=0.5071 logit_acc_rollout_kept=0.5613 +step=4850 micro_steps=19400 elapsed=264.4s lr=2.000000e-03 loss=2.6371 loss_recon=2.6371 loss_meanflow=0.0000 mean_model_t=0.5069 mean_corrupt_t=0.5069 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4913 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.2897 out_g_norm=0.6361 acc_all=0.8031 acc_corrupt=0.6188 corrupt_frac=0.5077 loss_all=1.3199 loss_corrupt=2.5445 acc_corrupt_t_0p0_0p2=0.1785 corrupt_frac_t_0p0_0p2=0.1283 acc_corrupt_t_0p2_0p4=0.3810 corrupt_frac_t_0p2_0p4=0.2467 acc_corrupt_t_0p4_0p6=0.6347 corrupt_frac_t_0p4_0p6=0.1455 acc_corrupt_t_0p6_0p8=0.7862 corrupt_frac_t_0p6_0p8=0.2865 acc_corrupt_t_0p8_1p0=0.9548 corrupt_frac_t_0p8_1p0=0.1930 wrong_frac=0.4624 init_acc_corrupt=0.5021 init_gold_top10=0.5532 init_gold_top100=0.6908 rollout_applied_pos_frac=0.5226 init_acc_rollout_applied=0.4852 init_acc_rollout_kept=0.5207 logit_acc_rollout_applied=0.5934 logit_acc_rollout_kept=0.6466 +step=4900 micro_steps=19600 elapsed=264.7s lr=2.000000e-03 loss=2.7468 loss_recon=2.7468 loss_meanflow=0.0000 mean_model_t=0.4914 mean_corrupt_t=0.4914 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4975 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.3874 out_g_norm=0.6572 acc_all=0.8023 acc_corrupt=0.6175 corrupt_frac=0.5065 loss_all=1.3284 loss_corrupt=2.5519 acc_corrupt_t_0p0_0p2=0.1773 corrupt_frac_t_0p0_0p2=0.1635 acc_corrupt_t_0p2_0p4=0.4181 corrupt_frac_t_0p2_0p4=0.2263 acc_corrupt_t_0p4_0p6=0.6571 corrupt_frac_t_0p4_0p6=0.1033 acc_corrupt_t_0p6_0p8=0.7897 corrupt_frac_t_0p6_0p8=0.3209 acc_corrupt_t_0p8_1p0=0.9278 corrupt_frac_t_0p8_1p0=0.1860 wrong_frac=0.4665 init_acc_corrupt=0.4969 init_gold_top10=0.5539 init_gold_top100=0.6735 rollout_applied_pos_frac=0.5183 init_acc_rollout_applied=0.5694 init_acc_rollout_kept=0.4188 logit_acc_rollout_applied=0.6773 logit_acc_rollout_kept=0.5532 +step=4950 micro_steps=19800 elapsed=267.6s lr=2.000000e-03 loss=2.7119 loss_recon=2.7119 loss_meanflow=0.0000 mean_model_t=0.4966 mean_corrupt_t=0.4966 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4894 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.4847 out_g_norm=0.6605 acc_all=0.8461 acc_corrupt=0.7472 corrupt_frac=0.6002 loss_all=1.0163 loss_corrupt=1.6589 acc_corrupt_t_0p0_0p2=0.1368 corrupt_frac_t_0p0_0p2=0.0703 acc_corrupt_t_0p2_0p4=0.4009 corrupt_frac_t_0p2_0p4=0.1190 acc_corrupt_t_0p4_0p6=0.6392 corrupt_frac_t_0p4_0p6=0.2013 acc_corrupt_t_0p6_0p8=0.8092 corrupt_frac_t_0p6_0p8=0.1516 acc_corrupt_t_0p8_1p0=0.9578 corrupt_frac_t_0p8_1p0=0.4578 wrong_frac=0.3191 init_acc_corrupt=0.6699 init_gold_top10=0.6982 init_gold_top100=0.7682 rollout_applied_pos_frac=0.4424 init_acc_rollout_applied=0.6858 init_acc_rollout_kept=0.6573 logit_acc_rollout_applied=0.7637 logit_acc_rollout_kept=0.7341 +step=5000 micro_steps=20000 elapsed=278.1s lr=2.000000e-03 loss=2.6961 loss_recon=2.6961 loss_meanflow=0.0000 mean_model_t=0.4959 mean_corrupt_t=0.4959 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5000 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.5818 out_g_norm=0.6682 acc_all=0.7656 acc_corrupt=0.6018 corrupt_frac=0.5767 loss_all=1.5618 loss_corrupt=2.6331 acc_corrupt_t_0p0_0p2=0.1855 corrupt_frac_t_0p0_0p2=0.2571 acc_corrupt_t_0p2_0p4=0.4811 corrupt_frac_t_0p2_0p4=0.0981 acc_corrupt_t_0p4_0p6=0.6288 corrupt_frac_t_0p4_0p6=0.2258 acc_corrupt_t_0p6_0p8=0.7978 corrupt_frac_t_0p6_0p8=0.1911 acc_corrupt_t_0p8_1p0=0.9324 corrupt_frac_t_0p8_1p0=0.2279 wrong_frac=0.4877 init_acc_corrupt=0.4875 init_gold_top10=0.5225 init_gold_top100=0.6129 rollout_applied_pos_frac=0.2151 init_acc_rollout_applied=0.4455 init_acc_rollout_kept=0.4990 logit_acc_rollout_applied=0.5943 logit_acc_rollout_kept=0.6039 +step=5050 micro_steps=20200 elapsed=283.6s lr=2.000000e-03 loss=2.7404 loss_recon=2.7404 loss_meanflow=0.0000 mean_model_t=0.4917 mean_corrupt_t=0.4917 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4919 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.6776 out_g_norm=0.6626 acc_all=0.8191 acc_corrupt=0.5995 corrupt_frac=0.4402 loss_all=1.1712 loss_corrupt=2.5739 acc_corrupt_t_0p0_0p2=0.2815 corrupt_frac_t_0p0_0p2=0.1990 acc_corrupt_t_0p2_0p4=0.4569 corrupt_frac_t_0p2_0p4=0.2335 acc_corrupt_t_0p4_0p6=0.5861 corrupt_frac_t_0p4_0p6=0.1940 acc_corrupt_t_0p6_0p8=0.8174 corrupt_frac_t_0p6_0p8=0.2274 acc_corrupt_t_0p8_1p0=0.9388 corrupt_frac_t_0p8_1p0=0.1461 wrong_frac=0.5253 init_acc_corrupt=0.4362 init_gold_top10=0.5142 init_gold_top100=0.7242 rollout_applied_pos_frac=0.6513 init_acc_rollout_applied=0.3992 init_acc_rollout_kept=0.5055 logit_acc_rollout_applied=0.5604 logit_acc_rollout_kept=0.6725 +step=5100 micro_steps=20400 elapsed=278.5s lr=2.000000e-03 loss=2.6612 loss_recon=2.6612 loss_meanflow=0.0000 mean_model_t=0.4967 mean_corrupt_t=0.4967 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4781 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.7733 out_g_norm=0.6359 acc_all=0.7800 acc_corrupt=0.6064 corrupt_frac=0.5504 loss_all=1.4298 loss_corrupt=2.5358 acc_corrupt_t_0p0_0p2=0.2381 corrupt_frac_t_0p0_0p2=0.1411 acc_corrupt_t_0p2_0p4=0.4141 corrupt_frac_t_0p2_0p4=0.2616 acc_corrupt_t_0p4_0p6=0.6100 corrupt_frac_t_0p4_0p6=0.1351 acc_corrupt_t_0p6_0p8=0.7951 corrupt_frac_t_0p6_0p8=0.3585 acc_corrupt_t_0p8_1p0=0.9358 corrupt_frac_t_0p8_1p0=0.1037 wrong_frac=0.4831 init_acc_corrupt=0.4860 init_gold_top10=0.5429 init_gold_top100=0.6955 rollout_applied_pos_frac=0.5554 init_acc_rollout_applied=0.4405 init_acc_rollout_kept=0.5428 logit_acc_rollout_applied=0.5723 logit_acc_rollout_kept=0.6490 +step=5150 micro_steps=20600 elapsed=278.5s lr=2.000000e-03 loss=2.6924 loss_recon=2.6924 loss_meanflow=0.0000 mean_model_t=0.5028 mean_corrupt_t=0.5028 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5200 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.8687 out_g_norm=0.6218 acc_all=0.7277 acc_corrupt=0.5412 corrupt_frac=0.5866 loss_all=1.8101 loss_corrupt=3.0360 acc_corrupt_t_0p0_0p2=0.1920 corrupt_frac_t_0p0_0p2=0.2484 acc_corrupt_t_0p2_0p4=0.3392 corrupt_frac_t_0p2_0p4=0.2147 acc_corrupt_t_0p4_0p6=0.5822 corrupt_frac_t_0p4_0p6=0.1564 acc_corrupt_t_0p6_0p8=0.8177 corrupt_frac_t_0p6_0p8=0.2030 acc_corrupt_t_0p8_1p0=0.9217 corrupt_frac_t_0p8_1p0=0.1775 wrong_frac=0.5394 init_acc_corrupt=0.4111 init_gold_top10=0.4748 init_gold_top100=0.6478 rollout_applied_pos_frac=0.5129 init_acc_rollout_applied=0.4933 init_acc_rollout_kept=0.3246 logit_acc_rollout_applied=0.6244 logit_acc_rollout_kept=0.4535 +step=5200 micro_steps=20800 elapsed=273.2s lr=2.000000e-03 loss=2.6411 loss_recon=2.6411 loss_meanflow=0.0000 mean_model_t=0.5073 mean_corrupt_t=0.5073 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5019 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=27.9639 out_g_norm=0.6405 acc_all=0.7854 acc_corrupt=0.5742 corrupt_frac=0.4953 loss_all=1.3860 loss_corrupt=2.7324 acc_corrupt_t_0p0_0p2=0.2210 corrupt_frac_t_0p0_0p2=0.1361 acc_corrupt_t_0p2_0p4=0.4233 corrupt_frac_t_0p2_0p4=0.3889 acc_corrupt_t_0p4_0p6=0.6389 corrupt_frac_t_0p4_0p6=0.1377 acc_corrupt_t_0p6_0p8=0.8274 corrupt_frac_t_0p6_0p8=0.2234 acc_corrupt_t_0p8_1p0=0.9361 corrupt_frac_t_0p8_1p0=0.1139 wrong_frac=0.5324 init_acc_corrupt=0.4313 init_gold_top10=0.4808 init_gold_top100=0.5829 rollout_applied_pos_frac=0.3484 init_acc_rollout_applied=0.5103 init_acc_rollout_kept=0.3891 logit_acc_rollout_applied=0.6346 logit_acc_rollout_kept=0.5418 +step=5250 micro_steps=21000 elapsed=264.6s lr=2.000000e-03 loss=2.6249 loss_recon=2.6249 loss_meanflow=0.0000 mean_model_t=0.5084 mean_corrupt_t=0.5084 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5075 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.0587 out_g_norm=0.6405 acc_all=0.7549 acc_corrupt=0.5487 corrupt_frac=0.5334 loss_all=1.6076 loss_corrupt=2.9395 acc_corrupt_t_0p0_0p2=0.1844 corrupt_frac_t_0p0_0p2=0.2374 acc_corrupt_t_0p2_0p4=0.4630 corrupt_frac_t_0p2_0p4=0.2188 acc_corrupt_t_0p4_0p6=0.5994 corrupt_frac_t_0p4_0p6=0.2490 acc_corrupt_t_0p6_0p8=0.7882 corrupt_frac_t_0p6_0p8=0.1599 acc_corrupt_t_0p8_1p0=0.9517 corrupt_frac_t_0p8_1p0=0.1349 wrong_frac=0.5535 init_acc_corrupt=0.4182 init_gold_top10=0.4586 init_gold_top100=0.6457 rollout_applied_pos_frac=0.5656 init_acc_rollout_applied=0.4088 init_acc_rollout_kept=0.4304 logit_acc_rollout_applied=0.5361 logit_acc_rollout_kept=0.5653 +step=5300 micro_steps=21200 elapsed=263.7s lr=2.000000e-03 loss=2.6617 loss_recon=2.6617 loss_meanflow=0.0000 mean_model_t=0.4939 mean_corrupt_t=0.4939 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5050 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.1529 out_g_norm=0.6360 acc_all=0.8334 acc_corrupt=0.6355 corrupt_frac=0.4472 loss_all=1.0741 loss_corrupt=2.3350 acc_corrupt_t_0p0_0p2=0.2063 corrupt_frac_t_0p0_0p2=0.1499 acc_corrupt_t_0p2_0p4=0.3914 corrupt_frac_t_0p2_0p4=0.1656 acc_corrupt_t_0p4_0p6=0.6748 corrupt_frac_t_0p4_0p6=0.2959 acc_corrupt_t_0p6_0p8=0.8065 corrupt_frac_t_0p6_0p8=0.1877 acc_corrupt_t_0p8_1p0=0.9392 corrupt_frac_t_0p8_1p0=0.2009 wrong_frac=0.4799 init_acc_corrupt=0.4989 init_gold_top10=0.5520 init_gold_top100=0.6728 rollout_applied_pos_frac=0.4668 init_acc_rollout_applied=0.4963 init_acc_rollout_kept=0.5012 logit_acc_rollout_applied=0.6317 logit_acc_rollout_kept=0.6388 +step=5350 micro_steps=21400 elapsed=263.5s lr=2.000000e-03 loss=2.6396 loss_recon=2.6396 loss_meanflow=0.0000 mean_model_t=0.4981 mean_corrupt_t=0.4981 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4869 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.2467 out_g_norm=0.6260 acc_all=0.7533 acc_corrupt=0.5759 corrupt_frac=0.5756 loss_all=1.6295 loss_corrupt=2.7853 acc_corrupt_t_0p0_0p2=0.1529 corrupt_frac_t_0p0_0p2=0.2240 acc_corrupt_t_0p2_0p4=0.4270 corrupt_frac_t_0p2_0p4=0.2580 acc_corrupt_t_0p4_0p6=0.5382 corrupt_frac_t_0p4_0p6=0.0700 acc_corrupt_t_0p6_0p8=0.7772 corrupt_frac_t_0p6_0p8=0.1416 acc_corrupt_t_0p8_1p0=0.9263 corrupt_frac_t_0p8_1p0=0.3064 wrong_frac=0.5001 init_acc_corrupt=0.4642 init_gold_top10=0.5145 init_gold_top100=0.6431 rollout_applied_pos_frac=0.4287 init_acc_rollout_applied=0.4746 init_acc_rollout_kept=0.4564 logit_acc_rollout_applied=0.5759 logit_acc_rollout_kept=0.5759 +step=5400 micro_steps=21600 elapsed=263.9s lr=2.000000e-03 loss=2.6384 loss_recon=2.6384 loss_meanflow=0.0000 mean_model_t=0.4998 mean_corrupt_t=0.4998 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5100 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.3411 out_g_norm=0.6417 acc_all=0.8222 acc_corrupt=0.6313 corrupt_frac=0.4716 loss_all=1.1686 loss_corrupt=2.4072 acc_corrupt_t_0p0_0p2=0.2120 corrupt_frac_t_0p0_0p2=0.2027 acc_corrupt_t_0p2_0p4=0.5105 corrupt_frac_t_0p2_0p4=0.1536 acc_corrupt_t_0p4_0p6=0.6129 corrupt_frac_t_0p4_0p6=0.2133 acc_corrupt_t_0p6_0p8=0.8174 corrupt_frac_t_0p6_0p8=0.1949 acc_corrupt_t_0p8_1p0=0.9335 corrupt_frac_t_0p8_1p0=0.2356 wrong_frac=0.4765 init_acc_corrupt=0.4962 init_gold_top10=0.5495 init_gold_top100=0.7296 rollout_applied_pos_frac=0.5777 init_acc_rollout_applied=0.4272 init_acc_rollout_kept=0.5905 logit_acc_rollout_applied=0.5581 logit_acc_rollout_kept=0.7314 +step=5450 micro_steps=21800 elapsed=487.2s lr=2.000000e-03 loss=2.5899 loss_recon=2.5899 loss_meanflow=0.0000 mean_model_t=0.4993 mean_corrupt_t=0.4993 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4969 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.4344 out_g_norm=0.6339 acc_all=0.8296 acc_corrupt=0.6776 corrupt_frac=0.5196 loss_all=1.0754 loss_corrupt=2.0122 acc_corrupt_t_0p0_0p2=0.3370 corrupt_frac_t_0p0_0p2=0.0973 acc_corrupt_t_0p2_0p4=0.4128 corrupt_frac_t_0p2_0p4=0.1963 acc_corrupt_t_0p4_0p6=0.6273 corrupt_frac_t_0p4_0p6=0.2665 acc_corrupt_t_0p6_0p8=0.7560 corrupt_frac_t_0p6_0p8=0.0850 acc_corrupt_t_0p8_1p0=0.9363 corrupt_frac_t_0p8_1p0=0.3550 wrong_frac=0.4297 init_acc_corrupt=0.5524 init_gold_top10=0.5976 init_gold_top100=0.7503 rollout_applied_pos_frac=0.5142 init_acc_rollout_applied=0.4576 init_acc_rollout_kept=0.6528 logit_acc_rollout_applied=0.6069 logit_acc_rollout_kept=0.7524 +step=5500 micro_steps=22000 elapsed=305.4s lr=2.000000e-03 loss=2.6772 loss_recon=2.6772 loss_meanflow=0.0000 mean_model_t=0.4990 mean_corrupt_t=0.4990 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5181 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.5276 out_g_norm=0.6230 acc_all=0.7473 acc_corrupt=0.5469 corrupt_frac=0.5494 loss_all=1.6910 loss_corrupt=3.0145 acc_corrupt_t_0p0_0p2=0.1347 corrupt_frac_t_0p0_0p2=0.2288 acc_corrupt_t_0p2_0p4=0.4152 corrupt_frac_t_0p2_0p4=0.1448 acc_corrupt_t_0p4_0p6=0.5967 corrupt_frac_t_0p4_0p6=0.3191 acc_corrupt_t_0p6_0p8=0.7359 corrupt_frac_t_0p6_0p8=0.1115 acc_corrupt_t_0p8_1p0=0.9370 corrupt_frac_t_0p8_1p0=0.1959 wrong_frac=0.5431 init_acc_corrupt=0.4299 init_gold_top10=0.4738 init_gold_top100=0.6361 rollout_applied_pos_frac=0.4777 init_acc_rollout_applied=0.3317 init_acc_rollout_kept=0.5197 logit_acc_rollout_applied=0.4342 logit_acc_rollout_kept=0.6500 +step=5550 micro_steps=22200 elapsed=397.4s lr=2.000000e-03 loss=2.7266 loss_recon=2.7266 loss_meanflow=0.0000 mean_model_t=0.4884 mean_corrupt_t=0.4884 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4744 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.6193 out_g_norm=0.6291 acc_all=0.7566 acc_corrupt=0.6078 corrupt_frac=0.6123 loss_all=1.5994 loss_corrupt=2.5643 acc_corrupt_t_0p0_0p2=0.1754 corrupt_frac_t_0p0_0p2=0.2327 acc_corrupt_t_0p2_0p4=0.3446 corrupt_frac_t_0p2_0p4=0.0956 acc_corrupt_t_0p4_0p6=0.6426 corrupt_frac_t_0p4_0p6=0.2495 acc_corrupt_t_0p6_0p8=0.8241 corrupt_frac_t_0p6_0p8=0.1541 acc_corrupt_t_0p8_1p0=0.9201 corrupt_frac_t_0p8_1p0=0.2681 wrong_frac=0.4759 init_acc_corrupt=0.4904 init_gold_top10=0.5467 init_gold_top100=0.7066 rollout_applied_pos_frac=0.5832 init_acc_rollout_applied=0.5207 init_acc_rollout_kept=0.4480 logit_acc_rollout_applied=0.6403 logit_acc_rollout_kept=0.5622 +step=5600 micro_steps=22400 elapsed=339.3s lr=2.000000e-03 loss=2.5791 loss_recon=2.5791 loss_meanflow=0.0000 mean_model_t=0.5041 mean_corrupt_t=0.5041 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.7113 out_g_norm=0.6200 acc_all=0.7878 acc_corrupt=0.5759 corrupt_frac=0.4915 loss_all=1.4289 loss_corrupt=2.8416 acc_corrupt_t_0p0_0p2=0.1490 corrupt_frac_t_0p0_0p2=0.2138 acc_corrupt_t_0p2_0p4=0.3914 corrupt_frac_t_0p2_0p4=0.1336 acc_corrupt_t_0p4_0p6=0.6157 corrupt_frac_t_0p4_0p6=0.2491 acc_corrupt_t_0p6_0p8=0.7712 corrupt_frac_t_0p6_0p8=0.2375 acc_corrupt_t_0p8_1p0=0.9349 corrupt_frac_t_0p8_1p0=0.1660 wrong_frac=0.5166 init_acc_corrupt=0.4556 init_gold_top10=0.5057 init_gold_top100=0.6633 rollout_applied_pos_frac=0.5370 init_acc_rollout_applied=0.4282 init_acc_rollout_kept=0.4875 logit_acc_rollout_applied=0.5429 logit_acc_rollout_kept=0.6142 +step=5650 micro_steps=22600 elapsed=264.9s lr=2.000000e-03 loss=2.5775 loss_recon=2.5775 loss_meanflow=0.0000 mean_model_t=0.5088 mean_corrupt_t=0.5088 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.8027 out_g_norm=0.6166 acc_all=0.7676 acc_corrupt=0.5849 corrupt_frac=0.5521 loss_all=1.4847 loss_corrupt=2.6326 acc_corrupt_t_0p0_0p2=0.2457 corrupt_frac_t_0p0_0p2=0.1518 acc_corrupt_t_0p2_0p4=0.3553 corrupt_frac_t_0p2_0p4=0.2783 acc_corrupt_t_0p4_0p6=0.6323 corrupt_frac_t_0p4_0p6=0.1777 acc_corrupt_t_0p6_0p8=0.7982 corrupt_frac_t_0p6_0p8=0.2257 acc_corrupt_t_0p8_1p0=0.9382 corrupt_frac_t_0p8_1p0=0.1664 wrong_frac=0.5044 init_acc_corrupt=0.4462 init_gold_top10=0.5203 init_gold_top100=0.7194 rollout_applied_pos_frac=0.6442 init_acc_rollout_applied=0.4249 init_acc_rollout_kept=0.4847 logit_acc_rollout_applied=0.5636 logit_acc_rollout_kept=0.6234 +step=5700 micro_steps=22800 elapsed=340.0s lr=2.000000e-03 loss=2.6540 loss_recon=2.6540 loss_meanflow=0.0000 mean_model_t=0.4989 mean_corrupt_t=0.4989 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4763 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.8943 out_g_norm=0.6104 acc_all=0.7207 acc_corrupt=0.5528 corrupt_frac=0.6179 loss_all=1.8200 loss_corrupt=2.9001 acc_corrupt_t_0p0_0p2=0.2306 corrupt_frac_t_0p0_0p2=0.1193 acc_corrupt_t_0p2_0p4=0.3779 corrupt_frac_t_0p2_0p4=0.3107 acc_corrupt_t_0p4_0p6=0.5791 corrupt_frac_t_0p4_0p6=0.2390 acc_corrupt_t_0p6_0p8=0.7560 corrupt_frac_t_0p6_0p8=0.2091 acc_corrupt_t_0p8_1p0=0.9133 corrupt_frac_t_0p8_1p0=0.1219 wrong_frac=0.5491 init_acc_corrupt=0.4118 init_gold_top10=0.4730 init_gold_top100=0.6425 rollout_applied_pos_frac=0.5466 init_acc_rollout_applied=0.4423 init_acc_rollout_kept=0.3751 logit_acc_rollout_applied=0.5684 logit_acc_rollout_kept=0.5339 +step=5750 micro_steps=23000 elapsed=267.3s lr=2.000000e-03 loss=2.6786 loss_recon=2.6786 loss_meanflow=0.0000 mean_model_t=0.4967 mean_corrupt_t=0.4967 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4969 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=28.9852 out_g_norm=0.6089 acc_all=0.7823 acc_corrupt=0.5949 corrupt_frac=0.5246 loss_all=1.3890 loss_corrupt=2.5631 acc_corrupt_t_0p0_0p2=0.2240 corrupt_frac_t_0p0_0p2=0.2319 acc_corrupt_t_0p2_0p4=0.4294 corrupt_frac_t_0p2_0p4=0.1310 acc_corrupt_t_0p4_0p6=0.6769 corrupt_frac_t_0p4_0p6=0.3133 acc_corrupt_t_0p6_0p8=0.7929 corrupt_frac_t_0p6_0p8=0.2211 acc_corrupt_t_0p8_1p0=0.9677 corrupt_frac_t_0p8_1p0=0.1027 wrong_frac=0.5180 init_acc_corrupt=0.4529 init_gold_top10=0.5080 init_gold_top100=0.7116 rollout_applied_pos_frac=0.6613 init_acc_rollout_applied=0.4276 init_acc_rollout_kept=0.5025 logit_acc_rollout_applied=0.5621 logit_acc_rollout_kept=0.6591 +step=5800 micro_steps=23200 elapsed=267.8s lr=2.000000e-03 loss=2.6538 loss_recon=2.6538 loss_meanflow=0.0000 mean_model_t=0.5046 mean_corrupt_t=0.5046 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4994 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=29.0757 out_g_norm=0.6109 acc_all=0.7390 acc_corrupt=0.5604 corrupt_frac=0.5862 loss_all=1.7402 loss_corrupt=2.9115 acc_corrupt_t_0p0_0p2=0.1746 corrupt_frac_t_0p0_0p2=0.3283 acc_corrupt_t_0p2_0p4=0.4877 corrupt_frac_t_0p2_0p4=0.1312 acc_corrupt_t_0p4_0p6=0.6356 corrupt_frac_t_0p4_0p6=0.1457 acc_corrupt_t_0p6_0p8=0.8122 corrupt_frac_t_0p6_0p8=0.2229 acc_corrupt_t_0p8_1p0=0.9622 corrupt_frac_t_0p8_1p0=0.1720 wrong_frac=0.5222 init_acc_corrupt=0.4371 init_gold_top10=0.4872 init_gold_top100=0.6450 rollout_applied_pos_frac=0.4537 init_acc_rollout_applied=0.4322 init_acc_rollout_kept=0.4412 logit_acc_rollout_applied=0.5672 logit_acc_rollout_kept=0.5547 +step=5850 micro_steps=23400 elapsed=274.0s lr=2.000000e-03 loss=2.6904 loss_recon=2.6904 loss_meanflow=0.0000 mean_model_t=0.4921 mean_corrupt_t=0.4921 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.5156 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=29.1658 out_g_norm=0.6209 acc_all=0.7282 acc_corrupt=0.5405 corrupt_frac=0.5833 loss_all=1.8313 loss_corrupt=3.0776 acc_corrupt_t_0p0_0p2=0.1947 corrupt_frac_t_0p0_0p2=0.3112 acc_corrupt_t_0p2_0p4=0.4060 corrupt_frac_t_0p2_0p4=0.2246 acc_corrupt_t_0p4_0p6=0.6587 corrupt_frac_t_0p4_0p6=0.0613 acc_corrupt_t_0p6_0p8=0.8225 corrupt_frac_t_0p6_0p8=0.2679 acc_corrupt_t_0p8_1p0=0.9484 corrupt_frac_t_0p8_1p0=0.1349 wrong_frac=0.5401 init_acc_corrupt=0.4037 init_gold_top10=0.4720 init_gold_top100=0.6282 rollout_applied_pos_frac=0.4885 init_acc_rollout_applied=0.4968 init_acc_rollout_kept=0.3147 logit_acc_rollout_applied=0.6166 logit_acc_rollout_kept=0.4678 +step=5900 micro_steps=23600 elapsed=266.7s lr=2.000000e-03 loss=2.5640 loss_recon=2.5640 loss_meanflow=0.0000 mean_model_t=0.5047 mean_corrupt_t=0.5047 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 rollout_train_applied=0.4938 grad_enabled_before_rollout=1.0000 grad_enabled_after_rollout=1.0000 logits_requires_grad=1.0000 raw_loss_requires_grad=1.0000 out_w_norm=29.2560 out_g_norm=0.5888 acc_all=0.8328 acc_corrupt=0.6618 corrupt_frac=0.4875 loss_all=1.0191 loss_corrupt=2.0424 acc_corrupt_t_0p0_0p2=0.3362 corrupt_frac_t_0p0_0p2=0.1383 acc_corrupt_t_0p2_0p4=0.4993 corrupt_frac_t_0p2_0p4=0.1888 acc_corrupt_t_0p4_0p6=0.5971 corrupt_frac_t_0p4_0p6=0.2710 acc_corrupt_t_0p6_0p8=0.7995 corrupt_frac_t_0p6_0p8=0.1305 acc_corrupt_t_0p8_1p0=0.9391 corrupt_frac_t_0p8_1p0=0.2714 wrong_frac=0.4489 init_acc_corrupt=0.5212 init_gold_top10=0.5727 init_gold_top100=0.7210 rollout_applied_pos_frac=0.5556 init_acc_rollout_applied=0.5662 init_acc_rollout_kept=0.4649 logit_acc_rollout_applied=0.6970 logit_acc_rollout_kept=0.6178 +W0514 10:02:35.508000 967100 torch/distributed/elastic/agent/server/api.py:719] Received 2 death signal, shutting down workers +W0514 10:02:35.509000 967100 torch/distributed/elastic/multiprocessing/api.py:898] Sending process 967106 closing signal SIGINT +W0514 10:02:35.510000 967100 torch/distributed/elastic/multiprocessing/api.py:898] Sending process 967107 closing signal SIGINT +W0514 10:02:35.510000 967100 torch/distributed/elastic/multiprocessing/api.py:898] Sending process 967108 closing signal SIGINT +W0514 10:02:35.511000 967100 torch/distributed/elastic/multiprocessing/api.py:898] Sending process 967109 closing signal SIGINT +[rank1]: Traceback (most recent call last): +[rank1]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1629, in +[rank1]: logits_requires_grad = bool(logits.requires_grad) + +[rank1]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1525, in main +[rank1]: "rollout_train_samplewise": args.rollout_train_samplewise, +[rank1]: ^^^^^^^^^^^^^^^ +[rank1]: File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward +[rank1]: torch.autograd.backward( +[rank1]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward +[rank1]: _engine_run_backward( +[rank1]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward +[rank1]: return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass +[rank1]: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +[rank1]: KeyboardInterrupt +[rank3]: Traceback (most recent call last): +[rank3]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1629, in +[rank3]: logits_requires_grad = bool(logits.requires_grad) + +[rank3]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1525, in main +[rank3]: "rollout_train_samplewise": args.rollout_train_samplewise, +[rank3]: ^^^^^^^^^^^^^^^ +[rank3]: File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward +[rank3]: torch.autograd.backward( +[rank3]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward +[rank3]: _engine_run_backward( +[rank3]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward +[rank3]: return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass +[rank3]: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +[rank3]: KeyboardInterrupt +[rank2]: Traceback (most recent call last): +[rank2]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1629, in +[rank2]: logits_requires_grad = bool(logits.requires_grad) + +[rank2]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1525, in main +[rank2]: "rollout_train_samplewise": args.rollout_train_samplewise, +[rank2]: ^^^^^^^^^^^^^^^ +[rank2]: File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward +[rank2]: torch.autograd.backward( +[rank2]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward +[rank2]: _engine_run_backward( +[rank2]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward +[rank2]: return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass +[rank2]: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +[rank2]: KeyboardInterrupt +[rank0]: Traceback (most recent call last): +[rank0]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1629, in +[rank0]: logits_requires_grad = bool(logits.requires_grad) + +[rank0]: File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1525, in main +[rank0]: "rollout_train_samplewise": args.rollout_train_samplewise, +[rank0]: ^^^^^^^^^^^^^^^ +[rank0]: File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward +[rank0]: torch.autograd.backward( +[rank0]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward +[rank0]: _engine_run_backward( +[rank0]: File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward +[rank0]: return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass +[rank0]: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +[rank0]: KeyboardInterrupt +[rank0]:[W514 10:02:36.307057485 ProcessGroupNCCL.cpp:1487] Warning: WARNING: destroy_process_group() was not called before program exit, which can leak resources. For more info, please see https://pytorch.org/docs/stable/distributed.html#shutdown (function operator()) +Traceback (most recent call last): + File "", line 198, in _run_module_as_main + File "", line 88, in _run_code + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/run.py", line 922, in + main() + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/elastic/multiprocessing/errors/__init__.py", line 355, in wrapper + return f(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^ + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/run.py", line 918, in main + run(args) + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/run.py", line 909, in run + elastic_launch( + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/launcher/api.py", line 139, in __call__ + return launch_agent(self._config, self._entrypoint, list(args)) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/launcher/api.py", line 261, in launch_agent + result = agent.run() + ^^^^^^^^^^^ + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/elastic/metrics/api.py", line 137, in wrapper + result = f(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^ + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/elastic/agent/server/api.py", line 711, in run + result = self._invoke_run(role) + ^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/elastic/agent/server/api.py", line 870, in _invoke_run + time.sleep(monitor_interval) + File "/usr/local/lib/python3.12/dist-packages/torch/distributed/elastic/multiprocessing/api.py", line 84, in _terminate_process_handler + raise SignalException(f"Process {os.getpid()} got signal: {sigval}", sigval=sigval) +torch.distributed.elastic.multiprocessing.api.SignalException: Process 967100 got signal: 2 diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/.lock b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/CACHEDIR.TAG b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/CACHEDIR.TAG new file mode 100644 index 0000000000000000000000000000000000000000..bc1ecb967a482524e7736038de0df6e08f9ee452 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/CACHEDIR.TAG @@ -0,0 +1 @@ +Signature: 8a477f597d28d172789f06886806bc55 \ No newline at end of file diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/__init__.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cfdc030a751b089fc7e38fc88093b791605d501d --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/__init__.py @@ -0,0 +1,45 @@ +from .core import ( + IDNABidiError, + IDNAError, + InvalidCodepoint, + InvalidCodepointContext, + alabel, + check_bidi, + check_hyphen_ok, + check_initial_combiner, + check_label, + check_nfc, + decode, + encode, + ulabel, + uts46_remap, + valid_contextj, + valid_contexto, + valid_label_length, + valid_string_length, +) +from .intranges import intranges_contain +from .package_data import __version__ + +__all__ = [ + "__version__", + "IDNABidiError", + "IDNAError", + "InvalidCodepoint", + "InvalidCodepointContext", + "alabel", + "check_bidi", + "check_hyphen_ok", + "check_initial_combiner", + "check_label", + "check_nfc", + "decode", + "encode", + "intranges_contain", + "ulabel", + "uts46_remap", + "valid_contextj", + "valid_contexto", + "valid_label_length", + "valid_string_length", +] diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/cli.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..4acda2c0f03561ee7e2a80611bdcb35900bb34e0 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/cli.py @@ -0,0 +1,128 @@ +"""Command-line interface for the :mod:`idna` package. + +Invoked via ``python -m idna``. See :func:`main` for the entry point. +""" + +import argparse +import sys +from collections.abc import Iterable +from itertools import chain +from typing import IO, Optional + +from . import IDNAError, decode, encode +from .core import _alabel_prefix, _unicode_dots_re +from .package_data import __version__ + + +def _looks_like_alabel(s: str) -> bool: + """Return True if any label in ``s`` carries the ``xn--`` ACE prefix.""" + prefix = _alabel_prefix.decode("ascii") + return any(label.lower().startswith(prefix) for label in _unicode_dots_re.split(s)) + + +def _build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + prog="python -m idna", + description=( + "Convert a domain name between its Unicode (U-label) and " + "ASCII-compatible (A-label) forms. With no mode flag, the " + "direction is chosen from the first input — if it contains " + "an xn-- label the stream is decoded, otherwise it is " + "encoded — and the same mode is applied to every remaining " + "input. UTS #46 mapping is applied by default; pass " + "--strict to disable it. When no domains are given on the " + "command line and stdin is piped, one domain per line is " + "read from stdin." + ), + ) + mode = parser.add_mutually_exclusive_group() + mode.add_argument( + "-e", + "--encode", + dest="mode", + action="store_const", + const="encode", + help="Encode the input to its ASCII A-label form.", + ) + mode.add_argument( + "-d", + "--decode", + dest="mode", + action="store_const", + const="decode", + help="Decode the input from its ASCII A-label form.", + ) + parser.add_argument( + "--strict", + action="store_true", + help="Disable the default UTS #46 mapping and apply IDNA 2008 rules verbatim.", + ) + parser.add_argument( + "--version", + action="version", + version=f"idna {__version__}", + ) + parser.add_argument( + "domain", + nargs="*", + help="One or more domain names to convert. Omit to read from stdin.", + ) + return parser + + +def _iter_stdin(stream: IO[str]) -> Iterable[str]: + """Yield non-empty stripped lines from ``stream``, ignoring blanks.""" + for line in stream: + stripped = line.strip() + if stripped: + yield stripped + + +def _convert_one(domain: str, mode: str, uts46: bool) -> bool: + """Convert ``domain`` and write the result; return ``False`` on failure.""" + try: + if mode == "decode": + print(decode(domain, uts46=uts46)) + else: + print(encode(domain, uts46=uts46).decode("ascii")) + except IDNAError as err: + print(f"idna: {mode} failed for {domain!r}: {err}", file=sys.stderr) + return False + return True + + +def main(argv: Optional[list[str]] = None) -> int: + """Entry point for ``python -m idna``. + + When more than one domain is supplied (via positional arguments or + piped stdin) and no mode flag is given, the first input determines + the direction and that mode is applied uniformly to the rest. + + :param argv: Argument list excluding the program name. Defaults to + :data:`sys.argv` when ``None``. + :returns: ``0`` on success, ``1`` if any conversion fails. + """ + parser = _build_parser() + args = parser.parse_args(argv) + uts46 = not args.strict + + if args.domain: + domains: Iterable[str] = args.domain + elif not sys.stdin.isatty(): + domains = _iter_stdin(sys.stdin) + else: + parser.error("a domain argument is required when stdin is a terminal") + + iterator = iter(domains) + first = next(iterator, None) + if first is None: + return 0 + + mode = args.mode or ("decode" if _looks_like_alabel(first) else "encode") + + results = [_convert_one(domain, mode, uts46) for domain in chain([first], iterator)] + return 0 if all(results) else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/core.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/core.py new file mode 100644 index 0000000000000000000000000000000000000000..da45b2ae9e4c300a6d6700b240a00d0f03af23d7 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/core.py @@ -0,0 +1,605 @@ +import bisect +import re +import unicodedata +import warnings +from typing import Optional, Union + +from . import idnadata +from .intranges import intranges_contain + +_virama_combining_class = 9 +_alabel_prefix = b"xn--" +_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]") + + +# Bidi category sets from RFC 5893, hoisted out of the per-codepoint loop +_bidi_rtl_first = frozenset({"R", "AL"}) +_bidi_rtl_categories = frozenset({"R", "AL", "AN"}) +_bidi_rtl_allowed = frozenset({"R", "AL", "AN", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"}) +_bidi_rtl_valid_ending = frozenset({"R", "AL", "EN", "AN"}) +_bidi_rtl_numeric = frozenset({"AN", "EN"}) +_bidi_ltr_allowed = frozenset({"L", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"}) +_bidi_ltr_valid_ending = frozenset({"L", "EN"}) +_bidi_joiner_l_or_d = frozenset({ord("L"), ord("D")}) +_bidi_joiner_r_or_d = frozenset({ord("R"), ord("D")}) + + +class IDNAError(UnicodeError): + """Base exception for all IDNA-encoding related problems""" + + +class IDNABidiError(IDNAError): + """Exception when bidirectional requirements are not satisfied""" + + +class InvalidCodepoint(IDNAError): + """Exception when a disallowed or unallocated codepoint is used""" + + +class InvalidCodepointContext(IDNAError): + """Exception when the codepoint is not valid in the context it is used""" + + +def _combining_class(cp: int) -> int: + v = unicodedata.combining(chr(cp)) + if v == 0 and not unicodedata.name(chr(cp)): + raise ValueError("Unknown character in unicodedata") + return v + + +def _is_script(cp: str, script: str) -> bool: + return intranges_contain(ord(cp), idnadata.scripts[script]) + + +def _punycode(s: str) -> bytes: + return s.encode("punycode") + + +def _unot(s: int) -> str: + return f"U+{s:04X}" + + +def valid_label_length(label: Union[bytes, str]) -> bool: + """Check that a label does not exceed the maximum permitted length. + + Per :rfc:`1035` (and :rfc:`5891` §4.2.4) a DNS label must not exceed + 63 octets. The argument may be either a :class:`str` (a U-label, where + length is measured in characters) or :class:`bytes` (an A-label, where + length is measured in octets). + + :param label: The label to check. + :returns: ``True`` if the label is within the length limit, otherwise + ``False``. + """ + return len(label) <= 63 + + +def valid_string_length(domain: Union[bytes, str], trailing_dot: bool) -> bool: + """Check that a full domain name does not exceed the maximum length. + + Per :rfc:`1035`, a domain name is limited to 253 octets when no trailing + dot is present, or 254 octets when one is included. + + :param domain: The full (possibly multi-label) domain name. + :param trailing_dot: ``True`` if ``domain`` includes a trailing ``.``. + :returns: ``True`` if the domain is within the length limit, otherwise + ``False``. + """ + return len(domain) <= (254 if trailing_dot else 253) + + +def check_bidi(label: str, check_ltr: bool = False) -> bool: + """Validate the Bidi Rule from :rfc:`5893` for a single label. + + The Bidi Rule constrains how bidirectional characters (Hebrew, Arabic, + etc.) may appear within a label. By default the check is only applied + when the label contains at least one right-to-left character (Unicode + bidirectional categories ``R``, ``AL``, or ``AN``); set ``check_ltr`` + to ``True`` to apply it to LTR-only labels as well. + + :param label: The label to validate, as a Unicode string. + :param check_ltr: If ``True``, apply the rules even when the label + contains no RTL characters. + :returns: ``True`` if the label satisfies the Bidi Rule. + :raises IDNABidiError: If any of Bidi Rule conditions 1-6 are violated, + or if the directional category of a codepoint cannot be determined. + """ + # Bidi rules should only be applied if string contains RTL characters + bidi_label = False + for idx, cp in enumerate(label, 1): + direction = unicodedata.bidirectional(cp) + if direction == "": + # String likely comes from a newer version of Unicode + raise IDNABidiError(f"Unknown directionality in label {label!r} at position {idx}") + if direction in _bidi_rtl_categories: + bidi_label = True + if not bidi_label and not check_ltr: + return True + + # Bidi rule 1 + direction = unicodedata.bidirectional(label[0]) + if direction in _bidi_rtl_first: + rtl = True + elif direction == "L": + rtl = False + else: + raise IDNABidiError(f"First codepoint in label {label!r} must be directionality L, R or AL") + + valid_ending = False + number_type: Optional[str] = None + for idx, cp in enumerate(label, 1): + direction = unicodedata.bidirectional(cp) + + if rtl: + # Bidi rule 2 + if direction not in _bidi_rtl_allowed: + raise IDNABidiError(f"Invalid direction for codepoint at position {idx} in a right-to-left label") + # Bidi rule 3 + if direction in _bidi_rtl_valid_ending: + valid_ending = True + elif direction != "NSM": + valid_ending = False + # Bidi rule 4 + if direction in _bidi_rtl_numeric: + if not number_type: + number_type = direction + elif number_type != direction: + raise IDNABidiError("Can not mix numeral types in a right-to-left label") + else: + # Bidi rule 5 + if direction not in _bidi_ltr_allowed: + raise IDNABidiError(f"Invalid direction for codepoint at position {idx} in a left-to-right label") + # Bidi rule 6 + if direction in _bidi_ltr_valid_ending: + valid_ending = True + elif direction != "NSM": + valid_ending = False + + if not valid_ending: + raise IDNABidiError("Label ends with illegal codepoint directionality") + + return True + + +def check_initial_combiner(label: str) -> bool: + """Reject labels that begin with a combining mark. + + Per :rfc:`5891` §4.2.3.2 a label must not start with a character of + Unicode general category ``M`` (Mark). + + :param label: The label to check. + :returns: ``True`` if the first character is not a combining mark. + :raises IDNAError: If the label begins with a combining character. + """ + if unicodedata.category(label[0])[0] == "M": + raise IDNAError("Label begins with an illegal combining character") + return True + + +def check_hyphen_ok(label: str) -> bool: + """Validate the hyphen restrictions for a label. + + Per :rfc:`5891` §4.2.3.1 a label must not start or end with a hyphen + (``U+002D``), and must not have hyphens in both the third and fourth + positions (the prefix reserved for A-labels). + + :param label: The label to check. + :returns: ``True`` if the hyphen restrictions are satisfied. + :raises IDNAError: If any of the hyphen restrictions are violated. + """ + if label[2:4] == "--": + raise IDNAError("Label has disallowed hyphens in 3rd and 4th position") + if label[0] == "-" or label[-1] == "-": + raise IDNAError("Label must not start or end with a hyphen") + return True + + +def check_nfc(label: str) -> None: + """Require that a label is in Unicode Normalization Form C. + + :param label: The label to check. + :raises IDNAError: If ``label`` differs from its NFC normalisation. + """ + if unicodedata.normalize("NFC", label) != label: + raise IDNAError("Label must be in Normalization Form C") + + +def valid_contextj(label: str, pos: int) -> bool: + """Validate the CONTEXTJ rules from :rfc:`5892` Appendix A. + + These rules govern the contextual use of the joiner codepoints + ``U+200C`` (ZERO WIDTH NON-JOINER, Appendix A.1) and ``U+200D`` + (ZERO WIDTH JOINER, Appendix A.2) within a label. + + :param label: The label containing the codepoint. + :param pos: Index of the joiner codepoint within ``label``. + :returns: ``True`` if the codepoint at ``pos`` satisfies its CONTEXTJ + rule, ``False`` otherwise (including when the codepoint at + ``pos`` is not a recognised joiner). + :raises ValueError: If an adjacent codepoint has no Unicode name when + determining its combining class. + """ + cp_value = ord(label[pos]) + + if cp_value == 0x200C: + if pos > 0 and _combining_class(ord(label[pos - 1])) == _virama_combining_class: + return True + + ok = False + for i in range(pos - 1, -1, -1): + joining_type = idnadata.joining_types().get(ord(label[i])) + if joining_type == ord("T"): + continue + if joining_type in _bidi_joiner_l_or_d: + ok = True + break + break + + if not ok: + return False + + ok = False + for i in range(pos + 1, len(label)): + joining_type = idnadata.joining_types().get(ord(label[i])) + if joining_type == ord("T"): + continue + if joining_type in _bidi_joiner_r_or_d: + ok = True + break + break + return ok + + if cp_value == 0x200D: + return pos > 0 and _combining_class(ord(label[pos - 1])) == _virama_combining_class + + return False + + +def valid_contexto(label: str, pos: int, exception: bool = False) -> bool: + """Validate the CONTEXTO rules from :rfc:`5892` Appendix A. + + Covers the contextual rules for codepoints such as MIDDLE DOT + (``U+00B7``), Greek lower numeral sign, Hebrew punctuation, Katakana + middle dot, and the Arabic-Indic / Extended Arabic-Indic digit ranges. + + :param label: The label containing the codepoint. + :param pos: Index of the codepoint within ``label``. + :param exception: Reserved for forward compatibility; currently unused. + :returns: ``True`` if the codepoint at ``pos`` satisfies its CONTEXTO + rule, ``False`` otherwise (including when the codepoint is not a + recognised CONTEXTO codepoint). + """ + cp_value = ord(label[pos]) + + if cp_value == 0x00B7: + return 0 < pos < len(label) - 1 and ord(label[pos - 1]) == 0x006C and ord(label[pos + 1]) == 0x006C + + if cp_value == 0x0375: + if pos < len(label) - 1 and len(label) > 1: + return _is_script(label[pos + 1], "Greek") + return False + + if cp_value in {0x05F3, 0x05F4}: + if pos > 0: + return _is_script(label[pos - 1], "Hebrew") + return False + + if cp_value == 0x30FB: + for cp in label: + if cp == "\u30fb": + continue + if _is_script(cp, "Hiragana") or _is_script(cp, "Katakana") or _is_script(cp, "Han"): + return True + return False + + if 0x660 <= cp_value <= 0x669: + return not any(0x6F0 <= ord(cp) <= 0x06F9 for cp in label) + + if 0x6F0 <= cp_value <= 0x6F9: + return not any(0x660 <= ord(cp) <= 0x0669 for cp in label) + + return False + + +def check_label(label: Union[str, bytes, bytearray]) -> None: + """Run the full set of IDNA 2008 validity checks on a single label. + + Applies, in order: NFC normalisation (:func:`check_nfc`), hyphen + restrictions (:func:`check_hyphen_ok`), the no-leading-combiner rule + (:func:`check_initial_combiner`), per-codepoint validity (PVALID, + CONTEXTJ, CONTEXTO classes from :rfc:`5892`), and the Bidi Rule + (:func:`check_bidi`). + + :param label: The label to validate. ``bytes`` or ``bytearray`` input + is decoded as UTF-8 first. + :raises IDNAError: If the label is empty or fails a structural rule. + :raises InvalidCodepoint: If the label contains a DISALLOWED or + UNASSIGNED codepoint. + :raises InvalidCodepointContext: If a CONTEXTJ or CONTEXTO codepoint + is not valid in its context. + :raises IDNABidiError: If the Bidi Rule is violated. + """ + if isinstance(label, (bytes, bytearray)): + label = label.decode("utf-8") + if len(label) == 0: + raise IDNAError("Empty Label") + + # Reject on domain length rather than label length so support some UTS 46 + # use cases, still reducing processing of label contextual rules + if not valid_string_length(label, trailing_dot=True): + raise IDNAError("Label too long") + + check_nfc(label) + check_hyphen_ok(label) + check_initial_combiner(label) + + for pos, cp in enumerate(label): + cp_value = ord(cp) + if intranges_contain(cp_value, idnadata.codepoint_classes["PVALID"]): + continue + if intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTJ"]): + try: + if not valid_contextj(label, pos): + raise InvalidCodepointContext(f"Joiner {_unot(cp_value)} not allowed at position {pos + 1} in {label!r}") + except ValueError as err: + raise IDNAError( + f"Unknown codepoint adjacent to joiner {_unot(cp_value)} at position {pos + 1} in {label!r}" + ) from err + elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTO"]): + if not valid_contexto(label, pos): + raise InvalidCodepointContext(f"Codepoint {_unot(cp_value)} not allowed at position {pos + 1} in {label!r}") + else: + raise InvalidCodepoint(f"Codepoint {_unot(cp_value)} at position {pos + 1} of {label!r} not allowed") + + check_bidi(label) + + +def alabel(label: str) -> bytes: + """Convert a single U-label into its A-label form. + + The result is the ASCII-Compatible Encoding (ACE) form per :rfc:`5891` + §4: the label is validated, Punycode-encoded, and prefixed with + ``xn--``. Pure ASCII labels that are already valid IDNA labels are + returned unchanged (as :class:`bytes`). + + :param label: The label to convert, as a Unicode string. + :returns: The A-label as ASCII-encoded :class:`bytes`. + :raises IDNAError: If the label is invalid or the resulting A-label + exceeds 63 octets. + """ + try: + label_bytes = label.encode("ascii") + except UnicodeEncodeError: + pass + else: + ulabel(label_bytes) + if not valid_label_length(label_bytes): + raise IDNAError("Label too long") + return label_bytes + + check_label(label) + label_bytes = _alabel_prefix + _punycode(label) + + if not valid_label_length(label_bytes): + raise IDNAError("Label too long") + + return label_bytes + + +def ulabel(label: Union[str, bytes, bytearray]) -> str: + """Convert a single A-label into its U-label form. + + Performs the inverse of :func:`alabel`: an ``xn--``-prefixed label is + Punycode-decoded and validated. Labels that are already Unicode (or + plain ASCII without the ACE prefix) are validated and returned as a + Unicode string. + + :param label: The label to convert. ``bytes`` or ``bytearray`` input + is treated as ASCII. + :returns: The U-label as a Unicode string. + :raises IDNAError: If the label is malformed or fails validation. + """ + if not isinstance(label, (bytes, bytearray)): + try: + label_bytes = label.encode("ascii") + except UnicodeEncodeError: + check_label(label) + return label + else: + label_bytes = bytes(label) + + label_bytes = label_bytes.lower() + if label_bytes.startswith(_alabel_prefix): + label_bytes = label_bytes[len(_alabel_prefix) :] + if not label_bytes: + raise IDNAError("Malformed A-label, no Punycode eligible content found") + if label_bytes.endswith(b"-"): + raise IDNAError("A-label must not end with a hyphen") + else: + check_label(label_bytes) + return label_bytes.decode("ascii") + + try: + label = label_bytes.decode("punycode") + except UnicodeError as err: + raise IDNAError("Invalid A-label") from err + check_label(label) + return label + + +def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False) -> str: + """Apply the UTS #46 character mapping to a domain string. + + Implements the mapping table from `UTS #46 §4 + `_: each character is kept, + replaced, or rejected based on its status (``V``, ``M``, ``D``, ``3``, + ``I``). The result is returned in Normalisation Form C. + + :param domain: The full domain name to remap. + :param std3_rules: If ``True``, apply the stricter STD3 ASCII rules + (status ``3`` codepoints raise instead of being kept or mapped). + :param transitional: If ``True``, use transitional processing (status + ``D`` codepoints are mapped instead of kept). Transitional + processing has been removed from UTS #46 and this option is + retained only for backwards compatibility. + :returns: The remapped domain, in Normalisation Form C. + :raises InvalidCodepoint: If the domain contains a disallowed + codepoint under the chosen rules. + """ + from .uts46data import uts46data + + output = "" + + for pos, char in enumerate(domain): + code_point = ord(char) + uts46row = uts46data[code_point if code_point < 256 else bisect.bisect_left(uts46data, (code_point, "Z")) - 1] + status = uts46row[1] + replacement: Optional[str] = None + if len(uts46row) == 3: + replacement = uts46row[2] # ty: ignore[index-out-of-bounds] + + # UTS #46 §4: V is always valid, D is deviation (kept unless transitional), + # 3 is disallowed-STD3 (kept unmapped if std3_rules is off and no mapping). + keep_as_is = ( + status == "V" or (status == "D" and not transitional) or (status == "3" and not std3_rules and replacement is None) + ) + # M is mapped, 3-with-replacement and transitional D fall through to the + # same replacement output path. + use_replacement = replacement is not None and ( + status == "M" or (status == "3" and not std3_rules) or (status == "D" and transitional) + ) + + if keep_as_is: + output += char + elif use_replacement: + assert replacement is not None # narrowed by use_replacement + output += replacement + elif status == "I": + continue + else: + raise InvalidCodepoint(f"Codepoint {_unot(code_point)} not allowed at position {pos + 1} in {domain!r}") + + return unicodedata.normalize("NFC", output) + + +def encode( + s: Union[str, bytes, bytearray], + strict: bool = False, + uts46: bool = False, + std3_rules: bool = False, + transitional: bool = False, +) -> bytes: + """Encode a Unicode domain name into its ASCII (A-label) form. + + Splits the input on label separators (only ``U+002E`` if ``strict`` is + set; otherwise also IDEOGRAPHIC FULL STOP ``U+3002``, FULLWIDTH FULL + STOP ``U+FF0E``, and HALFWIDTH IDEOGRAPHIC FULL STOP ``U+FF61``), + encodes each label with :func:`alabel`, and rejoins them with ``.``. + Optionally pre-processes the input through :func:`uts46_remap`. + + :param s: The domain name to encode. + :param strict: If ``True``, only ``U+002E`` is recognised as a label + separator. + :param uts46: If ``True``, apply UTS #46 mapping before encoding. + :param std3_rules: Forwarded to :func:`uts46_remap` when ``uts46`` is + ``True``. + :param transitional: Forwarded to :func:`uts46_remap` when ``uts46`` + is ``True``. Deprecated: emits a :class:`DeprecationWarning` and + will be removed in a future version. + :returns: The encoded domain as ASCII :class:`bytes`. + :raises IDNAError: If the domain is empty, contains an invalid label, + or exceeds the maximum domain length. + """ + if transitional: + warnings.warn( + "Transitional processing has been removed from UTS #46. " + "The transitional argument will be removed in a future version.", + DeprecationWarning, + stacklevel=2, + ) + if not isinstance(s, str): + try: + s = str(s, "ascii") + except (UnicodeDecodeError, TypeError) as err: + raise IDNAError("should pass a unicode string to the function rather than a byte string.") from err + if uts46: + s = uts46_remap(s, std3_rules, transitional) + + # Reject inputs that exceed the maximum DNS domain length up-front + # to avoid expensive computation on long inputs. + if not valid_string_length(s, trailing_dot=True): + raise IDNAError("Domain too long") + + trailing_dot = False + result = [] + labels = s.split(".") if strict else _unicode_dots_re.split(s) + if not labels or labels == [""]: + raise IDNAError("Empty domain") + if labels[-1] == "": + del labels[-1] + trailing_dot = True + for label in labels: + s = alabel(label) + if s: + result.append(s) + else: + raise IDNAError("Empty label") + if trailing_dot: + result.append(b"") + s = b".".join(result) + if not valid_string_length(s, trailing_dot): + raise IDNAError("Domain too long") + return s + + +def decode( + s: Union[str, bytes, bytearray], + strict: bool = False, + uts46: bool = False, + std3_rules: bool = False, +) -> str: + """Decode an A-label-encoded domain name back to Unicode. + + Splits the input on label separators (see :func:`encode` for the + rules), decodes each label with :func:`ulabel`, and rejoins them + with ``.``. Optionally pre-processes the input through + :func:`uts46_remap`. + + :param s: The domain name to decode. + :param strict: If ``True``, only ``U+002E`` is recognised as a label + separator. + :param uts46: If ``True``, apply UTS #46 mapping before decoding. + :param std3_rules: Forwarded to :func:`uts46_remap` when ``uts46`` is + ``True``. + :returns: The decoded domain as a Unicode string. + :raises IDNAError: If the input is not valid ASCII, contains an + invalid label, or is empty. + """ + if not isinstance(s, str): + try: + s = str(s, "ascii") + except (UnicodeDecodeError, TypeError) as err: + raise IDNAError("Invalid ASCII in A-label") from err + if uts46: + s = uts46_remap(s, std3_rules, False) + # Reject inputs that exceed the maximum DNS domain length up-front + # to avoid expensive computation on long inputs. + if not valid_string_length(s, trailing_dot=True): + raise IDNAError("Domain too long") + trailing_dot = False + result = [] + labels = s.split(".") if strict else _unicode_dots_re.split(s) + if not labels or labels == [""]: + raise IDNAError("Empty domain") + if not labels[-1]: + del labels[-1] + trailing_dot = True + for label in labels: + s = ulabel(label) + if s: + result.append(s) + else: + raise IDNAError("Empty label") + if trailing_dot: + result.append("") + return ".".join(result) diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/intranges.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/intranges.py new file mode 100644 index 0000000000000000000000000000000000000000..19d77810caf332a1f310bd3b734dab7bbd82f64c --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/idna/intranges.py @@ -0,0 +1,55 @@ +""" +Given a list of integers, made up of (hopefully) a small number of long runs +of consecutive integers, compute a representation of the form +((start1, end1), (start2, end2) ...). Then answer the question "was x present +in the original list?" in time O(log(# runs)). +""" + +import bisect + + +def intranges_from_list(list_: list[int]) -> tuple[int, ...]: + """Represent a list of integers as a sequence of ranges: + ((start_0, end_0), (start_1, end_1), ...), such that the original + integers are exactly those x such that start_i <= x < end_i for some i. + + Ranges are encoded as single integers (start << 32 | end), not as tuples. + """ + + sorted_list = sorted(list_) + ranges = [] + last_write = -1 + for i in range(len(sorted_list)): + if i + 1 < len(sorted_list) and sorted_list[i] == sorted_list[i + 1] - 1: + continue + current_range = sorted_list[last_write + 1 : i + 1] + ranges.append(_encode_range(current_range[0], current_range[-1] + 1)) + last_write = i + + return tuple(ranges) + + +def _encode_range(start: int, end: int) -> int: + return (start << 32) | end + + +def _decode_range(r: int) -> tuple[int, int]: + return (r >> 32), (r & ((1 << 32) - 1)) + + +def intranges_contain(int_: int, ranges: tuple[int, ...]) -> bool: + """Determine if `int_` falls into one of the ranges in `ranges`.""" + tuple_ = _encode_range(int_, 0) + pos = bisect.bisect_left(ranges, tuple_) + # we could be immediately ahead of a tuple (start, end) + # with start < int_ <= end + if pos > 0: + left, right = _decode_range(ranges[pos - 1]) + if left <= int_ < right: + return True + # or we could be immediately behind a tuple (int_, end) + if pos < len(ranges): + left, _ = _decode_range(ranges[pos]) + if left == int_: + return True + return False diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/__init__.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..58afedb911d8d2011afb3fae0a082ed904514dbd --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/__init__.py @@ -0,0 +1,27 @@ +# Copyright 2026 Poolside and the HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from typing import TYPE_CHECKING + +from ...utils import _LazyModule +from ...utils.import_utils import define_import_structure + + +if TYPE_CHECKING: + from .configuration_laguna import * + from .modeling_laguna import * +else: + import sys + + _file = globals()["__file__"] + sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__) diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/configuration_laguna.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/configuration_laguna.py new file mode 100644 index 0000000000000000000000000000000000000000..33f939f6db43445485a16d34a24a365dda68ed7b --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/configuration_laguna.py @@ -0,0 +1,168 @@ +# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨 +# This file was automatically generated from src/transformers/models/laguna/modular_laguna.py. +# Do NOT edit this file manually as any edits will be overwritten by the generation of +# the file from the modular. If any change should be done, please apply the change to the +# modular_laguna.py file directly. One of our CI enforces this. +# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨 +# Copyright 2026 Poolside and the HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from typing import Any, Literal + +from huggingface_hub.dataclasses import strict + +from ...configuration_utils import PreTrainedConfig +from ...modeling_rope_utils import RopeParameters +from ...utils import auto_docstring + + +@auto_docstring(checkpoint="poolside/laguna-XS.2") +@strict +class LagunaConfig(PreTrainedConfig): + r""" + num_attention_heads_per_layer (`list[int]`, *optional*): + Per-layer override for ``num_attention_heads``. Length must equal ``num_hidden_layers``. + mlp_layer_types (`list[str]`, *optional*): + Per-layer MLP type — ``"dense"`` or ``"sparse"``. Length must equal + ``num_hidden_layers``. Defaults to first layer dense, rest sparse. + moe_routed_scaling_factor (`float`, *optional*, defaults to 1.0): + Scalar applied to routed-expert output before combining with the shared-expert output. + moe_apply_router_weight_on_input (`bool`, *optional*, defaults to `False`): + Whether to apply router weights to the MoE input rather than the output. Not supported + in transformers yet; ``True`` will raise a ``NotImplementedError`` for now. + moe_router_logit_softcapping (`float`, *optional*, defaults to 0.0): + Scaling factor when applying tanh softcapping on the logits of the MoE router logits. + + Example: + + ```python + >>> from transformers import LagunaModel, LagunaConfig + + >>> configuration = LagunaConfig() + >>> model = LagunaModel(configuration) + >>> configuration = model.config + ``` + """ + + model_type = "laguna" + keys_to_ignore_at_inference = ["past_key_values"] + base_model_tp_plan = { + "layers.*.self_attn.q_proj": "colwise", + "layers.*.self_attn.k_proj": "colwise", + "layers.*.self_attn.v_proj": "colwise", + "layers.*.self_attn.g_proj": "colwise", + "layers.*.self_attn.o_proj": "rowwise", + "layers.*.self_attn.q_norm": "replicated_with_grad_allreduce", + "layers.*.self_attn.k_norm": "replicated_with_grad_allreduce", + "layers.*.mlp.gate_proj": "colwise", + "layers.*.mlp.up_proj": "colwise", + "layers.*.mlp.down_proj": "rowwise", + "layers.*.mlp.experts.gate_up_proj": "packed_colwise", + "layers.*.mlp.experts.down_proj": "rowwise", + "layers.*.mlp.experts": "moe_tp_experts", + "layers.*.mlp.shared_experts.gate_proj": "colwise", + "layers.*.mlp.shared_experts.up_proj": "colwise", + "layers.*.mlp.shared_experts.down_proj": "rowwise", + } + base_model_pp_plan = { + "embed_tokens": (["input_ids"], ["inputs_embeds"]), + "layers": (["hidden_states", "attention_mask"], ["hidden_states"]), + "norm": (["hidden_states"], ["hidden_states"]), + } + + vocab_size: int = 100352 + hidden_size: int = 2048 + intermediate_size: int = 8192 + num_hidden_layers: int = 40 + num_attention_heads: int = 48 + num_key_value_heads: int = 8 + hidden_act: str = "silu" + max_position_embeddings: int = 131072 + initializer_range: float = 0.02 + rms_norm_eps: float = 1e-6 + use_cache: bool = True + tie_word_embeddings: bool = False + rope_parameters: RopeParameters | dict | None = None + sliding_window: int = 512 + attention_dropout: float | int = 0.0 + moe_intermediate_size: int = 512 + shared_expert_intermediate_size: int = 512 + num_experts_per_tok: int = 8 + num_experts: int = 256 + output_router_logits: bool = False + router_aux_loss_coef: float = 0.001 + layer_types: list[str] | None = None + pad_token_id: int | None = None + bos_token_id: int | None = None + eos_token_id: int | list[int] | None = None + + # Laguna-specific attention + head_dim: int = 128 + attention_bias: bool = False + num_attention_heads_per_layer: list[int] | None = None + # Laguna-specific MoE + mlp_layer_types: list[str] | None = None + moe_routed_scaling_factor: float = 1.0 + moe_apply_router_weight_on_input: bool = False + moe_router_logit_softcapping: float = 0.0 + + def __post_init__(self, **kwargs): + if self.layer_types is None: + self.layer_types = ["full_attention"] * self.num_hidden_layers + if self.mlp_layer_types is None: + self.mlp_layer_types = ["dense"] + ["sparse"] * (self.num_hidden_layers - 1) + if self.num_attention_heads_per_layer is None: + self.num_attention_heads_per_layer = [self.num_attention_heads] * self.num_hidden_layers + + default_rope_params: dict[Literal["full_attention", "sliding_attention"], dict[str, Any]] = { + "full_attention": {"rope_type": "default", "rope_theta": 500000.0, "partial_rotary_factor": 0.5}, + "sliding_attention": {"rope_type": "default", "rope_theta": 10000.0, "partial_rotary_factor": 1.0}, + } + if self.rope_parameters is None: + self.rope_parameters = default_rope_params + + # rope_parameters is keyed by layer type; tell the validator those keys are intentional. + super().__post_init__(**kwargs, ignore_keys_at_rope_validation={"sliding_attention", "full_attention"}) + + def convert_rope_params_to_dict(self, **kwargs): + # No need to handle BC for new models, because they have no old-format `rope_scaling` + return kwargs + + def validate_architecture(self): + """Part of ``@strict``-powered validation.""" + if self.moe_apply_router_weight_on_input: + raise NotImplementedError( + "moe_apply_router_weight_on_input=True is not yet supported in the " + "transformers implementation of Laguna." + ) + if ( + self.num_attention_heads_per_layer is not None + and len(self.num_attention_heads_per_layer) != self.num_hidden_layers + ): + raise ValueError( + f"num_attention_heads_per_layer length ({len(self.num_attention_heads_per_layer)}) " + f"must equal num_hidden_layers ({self.num_hidden_layers})." + ) + if len(self.layer_types) != self.num_hidden_layers: + raise ValueError( + f"layer_types length ({len(self.layer_types)}) " + f"must equal num_hidden_layers ({self.num_hidden_layers})." + ) + if len(self.mlp_layer_types) != self.num_hidden_layers: + raise ValueError( + f"mlp_layer_types length ({len(self.mlp_layer_types)}) " + f"must equal num_hidden_layers ({self.num_hidden_layers})." + ) + + +__all__ = ["LagunaConfig"] diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/modeling_laguna.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/modeling_laguna.py new file mode 100644 index 0000000000000000000000000000000000000000..aa4060e77f5f03a3bc46aa6f1f9cf14423465e4b --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/modeling_laguna.py @@ -0,0 +1,759 @@ +# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨 +# This file was automatically generated from src/transformers/models/laguna/modular_laguna.py. +# Do NOT edit this file manually as any edits will be overwritten by the generation of +# the file from the modular. If any change should be done, please apply the change to the +# modular_laguna.py file directly. One of our CI enforces this. +# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨 +# Copyright 2026 Poolside and the HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from collections.abc import Callable +from typing import Optional + +import torch +import torch.nn.functional as F +from torch import nn + +from ... import initialization as init +from ...activations import ACT2FN +from ...cache_utils import Cache, DynamicCache +from ...generation import GenerationMixin +from ...integrations import use_experts_implementation, use_kernel_forward_from_hub, use_kernelized_func +from ...masking_utils import create_causal_mask, create_sliding_window_causal_mask +from ...modeling_flash_attention_utils import FlashAttentionKwargs +from ...modeling_layers import GradientCheckpointingLayer +from ...modeling_outputs import MoeCausalLMOutputWithPast, MoeModelOutputWithPast +from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update +from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel +from ...processing_utils import Unpack +from ...utils import auto_docstring, can_return_tuple +from ...utils.generic import TransformersKwargs, maybe_autocast, merge_with_config_defaults +from ...utils.output_capturing import OutputRecorder, capture_outputs +from .configuration_laguna import LagunaConfig + + +@use_kernel_forward_from_hub("RMSNorm") +class LagunaRMSNorm(nn.Module): + def __init__(self, hidden_size, eps: float = 1e-6) -> None: + """ + LagunaRMSNorm is equivalent to T5LayerNorm + """ + super().__init__() + self.weight = nn.Parameter(torch.ones(hidden_size)) + self.variance_epsilon = eps + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + variance = hidden_states.pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) + return self.weight * hidden_states.to(input_dtype) + + def extra_repr(self): + return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}" + + +class LagunaRotaryEmbedding(nn.Module): + inv_freq: torch.Tensor # fix linting for `register_buffer` + + def __init__(self, config: LagunaConfig): + super().__init__() + self.max_seq_len_cached = config.max_position_embeddings + self.original_max_seq_len = config.max_position_embeddings + self.config = config + self.layer_types = list(set(config.layer_types)) + self.rope_type = {} + for layer_type in self.layer_types: + rope_params = self.config.rope_parameters[layer_type] + if rope_params is None: + continue + + self.rope_type[layer_type] = rope_params["rope_type"] + rope_init_fn: Callable = self.compute_default_rope_parameters + if self.rope_type[layer_type] != "default": + rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type[layer_type]] + curr_inv_freq, curr_attention_scaling = rope_init_fn(self.config, layer_type=layer_type) + self.register_buffer(f"{layer_type}_inv_freq", curr_inv_freq, persistent=False) + self.register_buffer(f"{layer_type}_original_inv_freq", curr_inv_freq.clone(), persistent=False) + setattr(self, f"{layer_type}_attention_scaling", curr_attention_scaling) + + @staticmethod + def compute_default_rope_parameters( + config: LagunaConfig | None = None, + device: Optional["torch.device"] = None, + seq_len: int | None = None, + layer_type: str | None = None, + ) -> tuple["torch.Tensor", float]: + """ + Computes the inverse frequencies according to the original RoPE implementation + Args: + config ([`~transformers.PreTrainedConfig`]): + The model configuration. + device (`torch.device`): + The device to use for initialization of the inverse frequencies. + seq_len (`int`, *optional*): + The current sequence length. Unused for this type of RoPE. + layer_type (`str`, *optional*): + The current layer type if the model has different RoPE parameters per type. + Should not be used unless `config.layer_types is not None` + Returns: + Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the + post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE). + """ + base = config.rope_parameters[layer_type]["rope_theta"] + # key difference to gemma3: partial rope + partial_rotary_factor = config.rope_parameters[layer_type].get("partial_rotary_factor", 1.0) + head_dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads + dim = int(head_dim * partial_rotary_factor) + + attention_factor = 1.0 # Unused in this type of RoPE + + # Compute the inverse frequencies + inv_freq = 1.0 / ( + base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim) + ) + return inv_freq, attention_factor + + @torch.no_grad() + @dynamic_rope_update # power user: used with advanced RoPE types (e.g. dynamic rope) + def forward(self, x, position_ids, layer_type=None): + inv_freq = getattr(self, f"{layer_type}_inv_freq") + attention_scaling = getattr(self, f"{layer_type}_attention_scaling") + + inv_freq_expanded = inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device) + position_ids_expanded = position_ids[:, None, :].float() + + device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu" + with maybe_autocast(device_type=device_type, enabled=False): # Force float32 + freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2) + emb = torch.cat((freqs, freqs), dim=-1) + cos = emb.cos() * attention_scaling + sin = emb.sin() * attention_scaling + + return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype) + + +class LagunaMLP(nn.Module): + def __init__(self, config, intermediate_size=None): + super().__init__() + self.config = config + self.hidden_size = config.hidden_size + self.intermediate_size = config.intermediate_size if intermediate_size is None else intermediate_size + self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False) + self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False) + self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False) + self.act_fn = ACT2FN[config.hidden_act] + + def forward(self, x): + down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x)) + return down_proj + + +class LagunaTopKRouter(nn.Module): + def __init__(self, config): + super().__init__() + self.top_k = config.num_experts_per_tok + self.num_experts = config.num_experts + self.hidden_dim = config.hidden_size + self.weight = nn.Parameter(torch.zeros(self.num_experts, self.hidden_dim)) + self.e_score_correction_bias = nn.Parameter(torch.zeros(config.num_experts), requires_grad=False) + self.router_logit_softcapping = config.moe_router_logit_softcapping + + def forward( + self, + hidden_states: torch.Tensor, + ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + hidden_states = hidden_states.reshape(-1, self.hidden_dim) + router_logits = F.linear(hidden_states, self.weight).float() + # Optional logits softcapping + if self.router_logit_softcapping > 0.0: + router_logits = torch.tanh(router_logits / self.router_logit_softcapping) * self.router_logit_softcapping + # Sigmoid instead of softmax normalization + routing_scores = torch.sigmoid(router_logits) + + scores_for_selection = routing_scores + self.e_score_correction_bias.to(routing_scores.dtype) + _, selected_experts = torch.topk(scores_for_selection, self.top_k, dim=-1) + routing_weights = routing_scores.gather(-1, selected_experts) + routing_weights = routing_weights / routing_weights.sum(dim=-1, keepdim=True) + routing_weights = routing_weights.to(hidden_states.dtype) + + return router_logits, routing_weights, selected_experts + + +@use_experts_implementation +class LagunaExperts(nn.Module): + """Collection of expert weights stored as 3D tensors.""" + + def __init__(self, config): + super().__init__() + self.num_experts = config.num_experts + self.hidden_dim = config.hidden_size + self.intermediate_dim = config.moe_intermediate_size + self.gate_up_proj = nn.Parameter(torch.empty(self.num_experts, 2 * self.intermediate_dim, self.hidden_dim)) + self.down_proj = nn.Parameter(torch.empty(self.num_experts, self.hidden_dim, self.intermediate_dim)) + self.act_fn = ACT2FN[config.hidden_act] + + def forward( + self, + hidden_states: torch.Tensor, + top_k_index: torch.Tensor, + top_k_weights: torch.Tensor, + ) -> torch.Tensor: + final_hidden_states = torch.zeros_like(hidden_states) + with torch.no_grad(): + expert_mask = torch.nn.functional.one_hot(top_k_index, num_classes=self.num_experts) + expert_mask = expert_mask.permute(2, 1, 0) + expert_hit = torch.greater(expert_mask.sum(dim=(-1, -2)), 0).nonzero() + + for expert_idx in expert_hit: + expert_idx = expert_idx[0] + if expert_idx == self.num_experts: + continue + top_k_pos, token_idx = torch.where(expert_mask[expert_idx]) + current_state = hidden_states[token_idx] + gate, up = nn.functional.linear(current_state, self.gate_up_proj[expert_idx]).chunk(2, dim=-1) + current_hidden_states = self.act_fn(gate) * up + current_hidden_states = nn.functional.linear(current_hidden_states, self.down_proj[expert_idx]) + current_hidden_states = current_hidden_states * top_k_weights[token_idx, top_k_pos, None] + final_hidden_states.index_add_(0, token_idx, current_hidden_states.to(final_hidden_states.dtype)) + + return final_hidden_states + + +class LagunaSparseMoeBlock(nn.Module): + def __init__(self, config: LagunaConfig): + super().__init__() + self.experts = LagunaExperts(config) + self.gate = LagunaTopKRouter(config) + self.shared_experts = LagunaMLP(config, intermediate_size=config.shared_expert_intermediate_size) + self.routed_scaling_factor = config.moe_routed_scaling_factor + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + batch_size, sequence_length, hidden_dim = hidden_states.shape + hidden_states = hidden_states.view(-1, hidden_dim) + shared_output = self.shared_experts(hidden_states) + + _, routing_weights, selected_experts = self.gate(hidden_states) + hidden_states = self.experts(hidden_states, selected_experts, routing_weights) + # Additional scaling + hidden_states = hidden_states * self.routed_scaling_factor + hidden_states = hidden_states + shared_output + + hidden_states = hidden_states.reshape(batch_size, sequence_length, hidden_dim) + return hidden_states + + +def rotate_half(x): + """Rotates half the hidden dims of the input.""" + x1 = x[..., : x.shape[-1] // 2] + x2 = x[..., x.shape[-1] // 2 :] + return torch.cat((-x2, x1), dim=-1) + + +# Adapted from transformers.models.glm.modular_glm.apply_rotary_pos_emb +def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1): + """Applies Rotary Position Embedding to the query and key tensors. + + Removes the interleaving of cos and sin from GLM + + Args: + q (`torch.Tensor`): The query tensor. + k (`torch.Tensor`): The key tensor. + cos (`torch.Tensor`): The cosine part of the rotary embedding. + sin (`torch.Tensor`): The sine part of the rotary embedding. + unsqueeze_dim (`int`, *optional*, defaults to 1): + The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and + sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note + that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and + k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes + cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have + the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2. + Returns: + `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding. + """ + cos = cos.unsqueeze(unsqueeze_dim) + sin = sin.unsqueeze(unsqueeze_dim) + + # Keep half or full tensor for later concatenation + rotary_dim = cos.shape[-1] + q_rot, q_pass = q[..., :rotary_dim], q[..., rotary_dim:] + k_rot, k_pass = k[..., :rotary_dim], k[..., rotary_dim:] + + # Apply rotary embeddings on the first half or full tensor + q_embed = (q_rot * cos) + (rotate_half(q_rot) * sin) + k_embed = (k_rot * cos) + (rotate_half(k_rot) * sin) + + # Concatenate back to full shape + q_embed = torch.cat([q_embed, q_pass], dim=-1) + k_embed = torch.cat([k_embed, k_pass], dim=-1) + return q_embed, k_embed + + +def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor: + """ + This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch, + num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim) + """ + batch, num_key_value_heads, slen, head_dim = hidden_states.shape + if n_rep == 1: + return hidden_states + hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim) + return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim) + + +def eager_attention_forward( + module: nn.Module, + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + attention_mask: torch.Tensor | None, + scaling: float, + dropout: float = 0.0, + **kwargs: Unpack[TransformersKwargs], +): + key_states = repeat_kv(key, module.num_key_value_groups) + value_states = repeat_kv(value, module.num_key_value_groups) + + attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling + if attention_mask is not None: + attn_weights = attn_weights + attention_mask + + attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype) + attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training) + attn_output = torch.matmul(attn_weights, value_states) + attn_output = attn_output.transpose(1, 2).contiguous() + + return attn_output, attn_weights + + +@use_kernelized_func(apply_rotary_pos_emb) +class LagunaAttention(nn.Module): + """Afmoe-style SWA/GQA attention with Laguna-specific gating and per-layer head count.""" + + def __init__(self, config: LagunaConfig, layer_idx: int, num_heads: int): + super().__init__() + # Number of heads is controlled via `config.num_attention_heads_per_layer` + self.num_heads = num_heads + self.config = config + self.layer_idx = layer_idx + self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads) + self.num_key_value_groups = self.num_heads // config.num_key_value_heads + self.scaling = self.head_dim**-0.5 + self.attention_dropout = config.attention_dropout + self.is_causal = True + + self.q_proj = nn.Linear(config.hidden_size, self.num_heads * self.head_dim, bias=config.attention_bias) + self.k_proj = nn.Linear( + config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias + ) + self.v_proj = nn.Linear( + config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias + ) + self.o_proj = nn.Linear(self.num_heads * self.head_dim, config.hidden_size, bias=config.attention_bias) + # Parent LlamaAttention already sets: layer_idx, num_heads, num_key_value_heads, num_key_value_groups, head_dim + # We only add Laguna-specific attributes + self.is_local_attention = config.layer_types[layer_idx] == "sliding_attention" + self.sliding_window = config.sliding_window if self.is_local_attention else None + + self.q_norm = LagunaRMSNorm(self.head_dim, eps=config.rms_norm_eps) + self.k_norm = LagunaRMSNorm(self.head_dim, eps=config.rms_norm_eps) + self.g_proj = nn.Linear(config.hidden_size, self.num_heads, bias=False) + + def forward( + self, + hidden_states: torch.Tensor, + position_embeddings: tuple[torch.Tensor, torch.Tensor], + attention_mask: torch.Tensor | None, + past_key_values: Cache | None = None, + **kwargs: Unpack[FlashAttentionKwargs], + ) -> tuple[torch.Tensor, torch.Tensor | None]: + input_shape = hidden_states.shape[:-1] + hidden_shape = (*input_shape, -1, self.head_dim) + + query_states = self.q_proj(hidden_states).view(hidden_shape) + key_states = self.k_proj(hidden_states).view(hidden_shape) + value_states = self.v_proj(hidden_states).view(hidden_shape) + + query_states = self.q_norm(query_states).transpose(1, 2) + key_states = self.k_norm(key_states).transpose(1, 2) + value_states = value_states.transpose(1, 2) + + cos, sin = position_embeddings + query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin) + + if past_key_values is not None: + key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx) + + attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface( + self.config._attn_implementation, eager_attention_forward + ) + attn_output, attn_weights = attention_interface( + self, + query_states, + key_states, + value_states, + attention_mask, + dropout=0.0 if not self.training else self.attention_dropout, + scaling=self.scaling, + sliding_window=self.sliding_window, + **kwargs, + ) + + attn_output = attn_output.reshape(*input_shape, -1).contiguous() + + gate = F.softplus(self.g_proj(hidden_states).float()).to(attn_output.dtype) + attn_output = (attn_output.view(*input_shape, -1, self.head_dim) * gate.unsqueeze(-1)).view(*input_shape, -1) + + attn_output = self.o_proj(attn_output) + return attn_output, attn_weights + + +class LagunaDecoderLayer(GradientCheckpointingLayer): + def __init__(self, config: LagunaConfig, layer_idx: int): + super().__init__() + self.hidden_size = config.hidden_size + self.self_attn = LagunaAttention(config, layer_idx, config.num_attention_heads_per_layer[layer_idx]) + if config.mlp_layer_types[layer_idx] == "sparse": + self.mlp = LagunaSparseMoeBlock(config) + else: + self.mlp = LagunaMLP(config, intermediate_size=config.intermediate_size) + self.input_layernorm = LagunaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + self.post_attention_layernorm = LagunaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: torch.Tensor | None = None, + position_ids: torch.LongTensor | None = None, + past_key_values: Cache | None = None, + use_cache: bool | None = False, + position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None, + **kwargs: Unpack[TransformersKwargs], + ) -> torch.Tensor: + residual = hidden_states + hidden_states = self.input_layernorm(hidden_states) + # Self Attention + hidden_states, _ = self.self_attn( + hidden_states=hidden_states, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_values=past_key_values, + use_cache=use_cache, + position_embeddings=position_embeddings, + **kwargs, + ) + hidden_states = residual + hidden_states + + # Fully Connected + residual = hidden_states + hidden_states = self.post_attention_layernorm(hidden_states) + hidden_states = self.mlp(hidden_states) + hidden_states = residual + hidden_states + return hidden_states + + +@auto_docstring +class LagunaPreTrainedModel(PreTrainedModel): + config: LagunaConfig + base_model_prefix = "model" + supports_gradient_checkpointing = True + _no_split_modules = ["LagunaDecoderLayer"] + _skip_keys_device_placement = ["past_key_values"] + _supports_flash_attn = True + _supports_sdpa = True + _supports_flex_attn = True + + _can_compile_fullgraph = True + _supports_attention_backend = True + _can_record_outputs = { + "router_logits": OutputRecorder(LagunaTopKRouter, index=0), + "hidden_states": LagunaDecoderLayer, + "attentions": LagunaAttention, + } + + @torch.no_grad() + def _init_weights(self, module): + super()._init_weights(module) + std = self.config.initializer_range + if isinstance(module, LagunaExperts): + init.normal_(module.gate_up_proj, mean=0.0, std=std) + init.normal_(module.down_proj, mean=0.0, std=std) + elif isinstance(module, LagunaTopKRouter): + init.normal_(module.weight, mean=0.0, std=std) + if isinstance(module, LagunaTopKRouter): + torch.nn.init.zeros_(module.e_score_correction_bias) + elif isinstance(module, LagunaRotaryEmbedding): + for layer_type in module.layer_types: + rope_init_fn = module.compute_default_rope_parameters + if module.rope_type[layer_type] != "default": + rope_init_fn = ROPE_INIT_FUNCTIONS[module.rope_type[layer_type]] + curr_inv_freq, _ = rope_init_fn(module.config, layer_type=layer_type) + init.copy_(getattr(module, f"{layer_type}_inv_freq"), curr_inv_freq) + init.copy_(getattr(module, f"{layer_type}_original_inv_freq"), curr_inv_freq) + + +@auto_docstring +class LagunaModel(LagunaPreTrainedModel): + def __init__(self, config: LagunaConfig): + super().__init__(config) + self.padding_idx = config.pad_token_id + self.vocab_size = config.vocab_size + + self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx) + self.layers = nn.ModuleList( + [LagunaDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)] + ) + self.norm = LagunaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + self.rotary_emb = LagunaRotaryEmbedding(config=config) + self.gradient_checkpointing = False + + # Initialize weights and apply final processing + self.post_init() + + @merge_with_config_defaults + @capture_outputs + @auto_docstring + def forward( + self, + input_ids: torch.LongTensor | None = None, + attention_mask: torch.Tensor | None = None, + position_ids: torch.LongTensor | None = None, + past_key_values: Cache | None = None, + inputs_embeds: torch.FloatTensor | None = None, + use_cache: bool | None = None, + **kwargs: Unpack[TransformersKwargs], + ) -> MoeModelOutputWithPast: + if (input_ids is None) ^ (inputs_embeds is not None): + raise ValueError("You must specify exactly one of input_ids or inputs_embeds") + + if inputs_embeds is None: + inputs_embeds = self.embed_tokens(input_ids) + + if use_cache and past_key_values is None: + past_key_values = DynamicCache(config=self.config) + + if position_ids is None: + past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0 + position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens + position_ids = position_ids.unsqueeze(0) + + if not isinstance(causal_mask_mapping := attention_mask, dict): + mask_kwargs = { + "config": self.config, + "inputs_embeds": inputs_embeds, + "attention_mask": attention_mask, + "past_key_values": past_key_values, + "position_ids": position_ids, + } + mask_creation_functions = { + "full_attention": lambda: create_causal_mask(**mask_kwargs), + "sliding_attention": lambda: create_sliding_window_causal_mask(**mask_kwargs), + } + causal_mask_mapping = {} + for layer_type in set(self.config.layer_types): + causal_mask_mapping[layer_type] = mask_creation_functions[layer_type]() + + hidden_states = inputs_embeds + position_embeddings = {} + for layer_type in set(self.config.layer_types): + position_embeddings[layer_type] = self.rotary_emb(hidden_states, position_ids, layer_type) + + for i, decoder_layer in enumerate(self.layers[: self.config.num_hidden_layers]): + hidden_states = decoder_layer( + hidden_states, + attention_mask=causal_mask_mapping[self.config.layer_types[i]], + position_embeddings=position_embeddings[self.config.layer_types[i]], + position_ids=position_ids, + past_key_values=past_key_values, + **kwargs, + ) + + hidden_states = self.norm(hidden_states) + + return MoeModelOutputWithPast( + last_hidden_state=hidden_states, + past_key_values=past_key_values if use_cache else None, + ) + + +def load_balancing_loss_func( + gate_logits: torch.Tensor | tuple[torch.Tensor] | None, + num_experts: int | None = None, + top_k=2, + attention_mask: torch.Tensor | None = None, +) -> torch.Tensor | int: + r""" + Computes auxiliary load balancing loss as in Switch Transformer - implemented in Pytorch. + + See Switch Transformer (https://huggingface.co/papers/2101.03961) for more details. This function implements the loss + function presented in equations (4) - (6) of the paper. It aims at penalizing cases where the routing between + experts is too unbalanced. + + Args: + gate_logits: + Logits from the `gate`, should be a tuple of model.config.num_hidden_layers tensors of + shape [batch_size X sequence_length, num_experts]. + num_experts: + Number of experts + top_k: + The number of experts to route per-token, can be also interpreted as the `top-k` routing + parameter. + attention_mask (`torch.Tensor`, *optional*): + The attention_mask used in forward function + shape [batch_size X sequence_length] if not None. + + Returns: + The auxiliary loss. + """ + if gate_logits is None or not isinstance(gate_logits, tuple): + return 0 + + if isinstance(gate_logits, tuple): + compute_device = gate_logits[0].device + concatenated_gate_logits = torch.cat([layer_gate.to(compute_device) for layer_gate in gate_logits], dim=0) + + routing_weights = torch.nn.functional.softmax(concatenated_gate_logits, dim=-1) + + _, selected_experts = torch.topk(routing_weights, top_k, dim=-1) + + expert_mask = torch.nn.functional.one_hot(selected_experts, num_experts) + + if attention_mask is None: + # Compute the percentage of tokens routed to each experts + tokens_per_expert = torch.mean(expert_mask.float(), dim=0) + + # Compute the average probability of routing to these experts + router_prob_per_expert = torch.mean(routing_weights, dim=0) + else: + batch_size, sequence_length = attention_mask.shape + num_hidden_layers = concatenated_gate_logits.shape[0] // (batch_size * sequence_length) + + # Compute the mask that masks all padding tokens as 0 with the same shape of expert_mask + expert_attention_mask = ( + attention_mask[None, :, :, None, None] + .expand((num_hidden_layers, batch_size, sequence_length, top_k, num_experts)) + .reshape(-1, top_k, num_experts) + .to(compute_device) + ) + + # Compute the percentage of tokens routed to each experts + tokens_per_expert = torch.sum(expert_mask.float() * expert_attention_mask, dim=0) / torch.sum( + expert_attention_mask, dim=0 + ) + + # Compute the mask that masks all padding tokens as 0 with the same shape of tokens_per_expert + router_per_expert_attention_mask = ( + attention_mask[None, :, :, None] + .expand((num_hidden_layers, batch_size, sequence_length, num_experts)) + .reshape(-1, num_experts) + .to(compute_device) + ) + + # Compute the average probability of routing to these experts + router_prob_per_expert = torch.sum(routing_weights * router_per_expert_attention_mask, dim=0) / torch.sum( + router_per_expert_attention_mask, dim=0 + ) + + overall_loss = torch.sum(tokens_per_expert * router_prob_per_expert.unsqueeze(0)) + return overall_loss * num_experts + + +@auto_docstring +class LagunaForCausalLM(LagunaPreTrainedModel, GenerationMixin): + _tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"} + _tp_plan = {"lm_head": "colwise_gather_output"} + _pp_plan = {"lm_head": (["hidden_states"], ["logits"])} + + def __init__(self, config): + super().__init__(config) + self.model = LagunaModel(config) + self.vocab_size = config.vocab_size + self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False) + self.router_aux_loss_coef = config.router_aux_loss_coef + self.num_experts = config.num_experts + self.num_experts_per_tok = config.num_experts_per_tok + + # Initialize weights and apply final processing + self.post_init() + + @can_return_tuple + @auto_docstring + def forward( + self, + input_ids: torch.LongTensor | None = None, + attention_mask: torch.Tensor | None = None, + position_ids: torch.LongTensor | None = None, + past_key_values: Cache | None = None, + inputs_embeds: torch.FloatTensor | None = None, + labels: torch.LongTensor | None = None, + use_cache: bool | None = None, + output_router_logits: bool | None = None, + logits_to_keep: int | torch.Tensor = 0, + **kwargs: Unpack[TransformersKwargs], + ) -> MoeCausalLMOutputWithPast: + r""" + labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): + Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., + config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored + (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`. + """ + + output_router_logits = ( + output_router_logits if output_router_logits is not None else self.config.output_router_logits + ) + + # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn) + outputs: MoeModelOutputWithPast = self.model( + input_ids=input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_values=past_key_values, + inputs_embeds=inputs_embeds, + use_cache=use_cache, + output_router_logits=output_router_logits, + **kwargs, + ) + + hidden_states = outputs.last_hidden_state + # Only compute necessary logits, and do not upcast them to float if we are not computing the loss + slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep + logits = self.lm_head(hidden_states[:, slice_indices, :]) + + loss = None + if labels is not None: + loss = self.loss_function(logits, labels, self.vocab_size, **kwargs) + + aux_loss = None + if output_router_logits: + aux_loss = load_balancing_loss_func( + outputs.router_logits, + self.num_experts, + self.num_experts_per_tok, + attention_mask, + ) + if labels is not None: + loss += self.router_aux_loss_coef * aux_loss.to(loss.device) # make sure to reside in the same device + + return MoeCausalLMOutputWithPast( + loss=loss, + aux_loss=aux_loss, + logits=logits, + past_key_values=outputs.past_key_values, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + router_logits=outputs.router_logits, + ) + + +__all__ = ["LagunaForCausalLM", "LagunaModel", "LagunaPreTrainedModel"] diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/modular_laguna.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/modular_laguna.py new file mode 100644 index 0000000000000000000000000000000000000000..945cd40a99b2d3a55009b3abdcd250ce595dad39 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/laguna/modular_laguna.py @@ -0,0 +1,455 @@ +# Copyright 2026 Poolside and the HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""PyTorch Laguna model.""" + +from collections.abc import Callable +from typing import Any, Literal, Optional + +import torch +import torch.nn.functional as F +from huggingface_hub.dataclasses import strict +from torch import nn + +from ... import initialization as init +from ...cache_utils import Cache, DynamicCache +from ...configuration_utils import PreTrainedConfig +from ...masking_utils import create_causal_mask, create_sliding_window_causal_mask +from ...modeling_flash_attention_utils import FlashAttentionKwargs +from ...modeling_outputs import MoeModelOutputWithPast +from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS +from ...modeling_utils import ALL_ATTENTION_FUNCTIONS +from ...processing_utils import Unpack +from ...utils import auto_docstring, logging +from ...utils.generic import TransformersKwargs +from ..afmoe.modeling_afmoe import AfmoeAttention +from ..gemma3.modeling_gemma3 import Gemma3RotaryEmbedding +from ..glm4_moe_lite.modeling_glm4_moe_lite import Glm4MoeLiteDecoderLayer +from ..llama.modeling_llama import LlamaModel, eager_attention_forward +from ..qwen2_moe.configuration_qwen2_moe import Qwen2MoeConfig +from ..qwen2_moe.modeling_qwen2_moe import Qwen2MoeForCausalLM, Qwen2MoeMLP, Qwen2MoePreTrainedModel, Qwen2MoeRMSNorm +from ..qwen3_5_moe.modeling_qwen3_5_moe import Qwen3_5MoeTopKRouter, apply_rotary_pos_emb +from ..qwen3_moe.modeling_qwen3_moe import Qwen3MoeExperts, Qwen3MoeSparseMoeBlock + + +logger = logging.get_logger(__name__) + + +@auto_docstring(checkpoint="poolside/laguna-XS.2") +@strict +class LagunaConfig(Qwen2MoeConfig): + r""" + num_attention_heads_per_layer (`list[int]`, *optional*): + Per-layer override for ``num_attention_heads``. Length must equal ``num_hidden_layers``. + mlp_layer_types (`list[str]`, *optional*): + Per-layer MLP type — ``"dense"`` or ``"sparse"``. Length must equal + ``num_hidden_layers``. Defaults to first layer dense, rest sparse. + moe_routed_scaling_factor (`float`, *optional*, defaults to 1.0): + Scalar applied to routed-expert output before combining with the shared-expert output. + moe_apply_router_weight_on_input (`bool`, *optional*, defaults to `False`): + Whether to apply router weights to the MoE input rather than the output. Not supported + in transformers yet; ``True`` will raise a ``NotImplementedError`` for now. + moe_router_logit_softcapping (`float`, *optional*, defaults to 0.0): + Scaling factor when applying tanh softcapping on the logits of the MoE router logits. + + Example: + + ```python + >>> from transformers import LagunaModel, LagunaConfig + + >>> configuration = LagunaConfig() + >>> model = LagunaModel(configuration) + >>> configuration = model.config + ``` + """ + + model_type = "laguna" + base_model_tp_plan = { + "layers.*.self_attn.q_proj": "colwise", + "layers.*.self_attn.k_proj": "colwise", + "layers.*.self_attn.v_proj": "colwise", + "layers.*.self_attn.g_proj": "colwise", + "layers.*.self_attn.o_proj": "rowwise", + "layers.*.self_attn.q_norm": "replicated_with_grad_allreduce", + "layers.*.self_attn.k_norm": "replicated_with_grad_allreduce", + "layers.*.mlp.gate_proj": "colwise", + "layers.*.mlp.up_proj": "colwise", + "layers.*.mlp.down_proj": "rowwise", + "layers.*.mlp.experts.gate_up_proj": "packed_colwise", + "layers.*.mlp.experts.down_proj": "rowwise", + "layers.*.mlp.experts": "moe_tp_experts", + "layers.*.mlp.shared_experts.gate_proj": "colwise", + "layers.*.mlp.shared_experts.up_proj": "colwise", + "layers.*.mlp.shared_experts.down_proj": "rowwise", + } + + vocab_size: int = 100352 + intermediate_size: int = 8192 + num_hidden_layers: int = 40 + num_attention_heads: int = 48 + num_key_value_heads: int = 8 + max_position_embeddings: int = 131072 + num_experts: int = 256 + num_experts_per_tok: int = 8 + moe_intermediate_size: int = 512 + shared_expert_intermediate_size: int = 512 + sliding_window: int = 512 + + # Laguna-specific attention + head_dim: int = 128 + attention_bias: bool = False + num_attention_heads_per_layer: list[int] | None = None + # Laguna-specific MoE + mlp_layer_types: list[str] | None = None + moe_routed_scaling_factor: float = 1.0 + moe_apply_router_weight_on_input: bool = False + moe_router_logit_softcapping: float = 0.0 + + # Fields declared by Qwen2MoeConfig but not used by Laguna. ``= AttributeError()`` + # tells modular to drop these from the materialized child. + decoder_sparse_step = AttributeError() + mlp_only_layers = AttributeError() + qkv_bias = AttributeError() + norm_topk_prob = AttributeError() + use_sliding_window = AttributeError() + max_window_layers = AttributeError() + + def __post_init__(self, **kwargs): + if self.layer_types is None: + self.layer_types = ["full_attention"] * self.num_hidden_layers + if self.mlp_layer_types is None: + self.mlp_layer_types = ["dense"] + ["sparse"] * (self.num_hidden_layers - 1) + if self.num_attention_heads_per_layer is None: + self.num_attention_heads_per_layer = [self.num_attention_heads] * self.num_hidden_layers + + default_rope_params: dict[Literal["full_attention", "sliding_attention"], dict[str, Any]] = { + "full_attention": {"rope_type": "default", "rope_theta": 500000.0, "partial_rotary_factor": 0.5}, + "sliding_attention": {"rope_type": "default", "rope_theta": 10000.0, "partial_rotary_factor": 1.0}, + } + if self.rope_parameters is None: + self.rope_parameters = default_rope_params + + # rope_parameters is keyed by layer type; tell the validator those keys are intentional. + PreTrainedConfig.__post_init__( + self, **kwargs, ignore_keys_at_rope_validation={"sliding_attention", "full_attention"} + ) + + def convert_rope_params_to_dict(self, **kwargs): + # No need to handle BC for new models, because they have no old-format `rope_scaling` + return kwargs + + def validate_architecture(self): + """Part of ``@strict``-powered validation.""" + if self.moe_apply_router_weight_on_input: + raise NotImplementedError( + "moe_apply_router_weight_on_input=True is not yet supported in the " + "transformers implementation of Laguna." + ) + if ( + self.num_attention_heads_per_layer is not None + and len(self.num_attention_heads_per_layer) != self.num_hidden_layers + ): + raise ValueError( + f"num_attention_heads_per_layer length ({len(self.num_attention_heads_per_layer)}) " + f"must equal num_hidden_layers ({self.num_hidden_layers})." + ) + if len(self.layer_types) != self.num_hidden_layers: + raise ValueError( + f"layer_types length ({len(self.layer_types)}) " + f"must equal num_hidden_layers ({self.num_hidden_layers})." + ) + if len(self.mlp_layer_types) != self.num_hidden_layers: + raise ValueError( + f"mlp_layer_types length ({len(self.mlp_layer_types)}) " + f"must equal num_hidden_layers ({self.num_hidden_layers})." + ) + + +class LagunaRMSNorm(Qwen2MoeRMSNorm): + pass + + +class LagunaRotaryEmbedding(Gemma3RotaryEmbedding): + def __init__(self, config: LagunaConfig): + super().__init__(config) + + @staticmethod + def compute_default_rope_parameters( + config: LagunaConfig | None = None, + device: Optional["torch.device"] = None, + seq_len: int | None = None, + layer_type: str | None = None, + ) -> tuple["torch.Tensor", float]: + """ + Computes the inverse frequencies according to the original RoPE implementation + Args: + config ([`~transformers.PreTrainedConfig`]): + The model configuration. + device (`torch.device`): + The device to use for initialization of the inverse frequencies. + seq_len (`int`, *optional*): + The current sequence length. Unused for this type of RoPE. + layer_type (`str`, *optional*): + The current layer type if the model has different RoPE parameters per type. + Should not be used unless `config.layer_types is not None` + Returns: + Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the + post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE). + """ + base = config.rope_parameters[layer_type]["rope_theta"] + # key difference to gemma3: partial rope + partial_rotary_factor = config.rope_parameters[layer_type].get("partial_rotary_factor", 1.0) + head_dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads + dim = int(head_dim * partial_rotary_factor) + + attention_factor = 1.0 # Unused in this type of RoPE + + # Compute the inverse frequencies + inv_freq = 1.0 / ( + base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim) + ) + return inv_freq, attention_factor + + +class LagunaMLP(Qwen2MoeMLP): + pass + + +class LagunaTopKRouter(Qwen3_5MoeTopKRouter): + def __init__(self, config): + super().__init__() + self.e_score_correction_bias = nn.Parameter(torch.zeros(config.num_experts), requires_grad=False) + self.router_logit_softcapping = config.moe_router_logit_softcapping + + def forward( + self, + hidden_states: torch.Tensor, + ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + hidden_states = hidden_states.reshape(-1, self.hidden_dim) + router_logits = F.linear(hidden_states, self.weight).float() + # Optional logits softcapping + if self.router_logit_softcapping > 0.0: + router_logits = torch.tanh(router_logits / self.router_logit_softcapping) * self.router_logit_softcapping + # Sigmoid instead of softmax normalization + routing_scores = torch.sigmoid(router_logits) + + scores_for_selection = routing_scores + self.e_score_correction_bias.to(routing_scores.dtype) + _, selected_experts = torch.topk(scores_for_selection, self.top_k, dim=-1) + routing_weights = routing_scores.gather(-1, selected_experts) + routing_weights = routing_weights / routing_weights.sum(dim=-1, keepdim=True) + routing_weights = routing_weights.to(hidden_states.dtype) + + return router_logits, routing_weights, selected_experts + + +class LagunaExperts(Qwen3MoeExperts): + pass + + +class LagunaSparseMoeBlock(Qwen3MoeSparseMoeBlock): + def __init__(self, config: LagunaConfig): + super().__init__(config) + self.shared_experts = LagunaMLP(config, intermediate_size=config.shared_expert_intermediate_size) + self.routed_scaling_factor = config.moe_routed_scaling_factor + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + batch_size, sequence_length, hidden_dim = hidden_states.shape + hidden_states = hidden_states.view(-1, hidden_dim) + shared_output = self.shared_experts(hidden_states) + + _, routing_weights, selected_experts = self.gate(hidden_states) + hidden_states = self.experts(hidden_states, selected_experts, routing_weights) + # Additional scaling + hidden_states = hidden_states * self.routed_scaling_factor + hidden_states = hidden_states + shared_output + + hidden_states = hidden_states.reshape(batch_size, sequence_length, hidden_dim) + return hidden_states + + +class LagunaAttention(AfmoeAttention): + """Afmoe-style SWA/GQA attention with Laguna-specific gating and per-layer head count.""" + + def __init__(self, config: LagunaConfig, layer_idx: int, num_heads: int): + # Number of heads is controlled via `config.num_attention_heads_per_layer` + self.num_heads = num_heads + + super().__init__(config, layer_idx) + self.num_key_value_groups = self.num_heads // config.num_key_value_heads + + self.q_proj = nn.Linear(config.hidden_size, self.num_heads * self.head_dim, bias=config.attention_bias) + self.o_proj = nn.Linear(self.num_heads * self.head_dim, config.hidden_size, bias=config.attention_bias) + + # Custom per-head gating + del self.gate_proj + self.g_proj = nn.Linear(config.hidden_size, self.num_heads, bias=False) + + def forward( + self, + hidden_states: torch.Tensor, + position_embeddings: tuple[torch.Tensor, torch.Tensor], + attention_mask: torch.Tensor | None, + past_key_values: Cache | None = None, + **kwargs: Unpack[FlashAttentionKwargs], + ) -> tuple[torch.Tensor, torch.Tensor | None]: + input_shape = hidden_states.shape[:-1] + hidden_shape = (*input_shape, -1, self.head_dim) + + query_states = self.q_proj(hidden_states).view(hidden_shape) + key_states = self.k_proj(hidden_states).view(hidden_shape) + value_states = self.v_proj(hidden_states).view(hidden_shape) + + query_states = self.q_norm(query_states).transpose(1, 2) + key_states = self.k_norm(key_states).transpose(1, 2) + value_states = value_states.transpose(1, 2) + + cos, sin = position_embeddings + query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin) + + if past_key_values is not None: + key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx) + + attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface( + self.config._attn_implementation, eager_attention_forward + ) + attn_output, attn_weights = attention_interface( + self, + query_states, + key_states, + value_states, + attention_mask, + dropout=0.0 if not self.training else self.attention_dropout, + scaling=self.scaling, + sliding_window=self.sliding_window, + **kwargs, + ) + + attn_output = attn_output.reshape(*input_shape, -1).contiguous() + + gate = F.softplus(self.g_proj(hidden_states).float()).to(attn_output.dtype) + attn_output = (attn_output.view(*input_shape, -1, self.head_dim) * gate.unsqueeze(-1)).view(*input_shape, -1) + + attn_output = self.o_proj(attn_output) + return attn_output, attn_weights + + +class LagunaDecoderLayer(Glm4MoeLiteDecoderLayer): + def __init__(self, config: LagunaConfig, layer_idx: int): + nn.Module.__init__(self) + self.hidden_size = config.hidden_size + self.self_attn = LagunaAttention(config, layer_idx, config.num_attention_heads_per_layer[layer_idx]) + if config.mlp_layer_types[layer_idx] == "sparse": + self.mlp = LagunaSparseMoeBlock(config) + else: + self.mlp = LagunaMLP(config, intermediate_size=config.intermediate_size) + self.input_layernorm = LagunaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + self.post_attention_layernorm = LagunaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + + +class LagunaPreTrainedModel(Qwen2MoePreTrainedModel): + @torch.no_grad() + def _init_weights(self, module): + super()._init_weights(module) + if isinstance(module, LagunaTopKRouter): + torch.nn.init.zeros_(module.e_score_correction_bias) + elif isinstance(module, LagunaRotaryEmbedding): + for layer_type in module.layer_types: + rope_init_fn = module.compute_default_rope_parameters + if module.rope_type[layer_type] != "default": + rope_init_fn = ROPE_INIT_FUNCTIONS[module.rope_type[layer_type]] + curr_inv_freq, _ = rope_init_fn(module.config, layer_type=layer_type) + init.copy_(getattr(module, f"{layer_type}_inv_freq"), curr_inv_freq) + init.copy_(getattr(module, f"{layer_type}_original_inv_freq"), curr_inv_freq) + + +class LagunaModel(LlamaModel): + def forward( + self, + input_ids: torch.LongTensor | None = None, + attention_mask: torch.Tensor | None = None, + position_ids: torch.LongTensor | None = None, + past_key_values: Cache | None = None, + inputs_embeds: torch.FloatTensor | None = None, + use_cache: bool | None = None, + **kwargs: Unpack[TransformersKwargs], + ) -> MoeModelOutputWithPast: + if (input_ids is None) ^ (inputs_embeds is not None): + raise ValueError("You must specify exactly one of input_ids or inputs_embeds") + + if inputs_embeds is None: + inputs_embeds = self.embed_tokens(input_ids) + + if use_cache and past_key_values is None: + past_key_values = DynamicCache(config=self.config) + + if position_ids is None: + past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0 + position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens + position_ids = position_ids.unsqueeze(0) + + if not isinstance(causal_mask_mapping := attention_mask, dict): + mask_kwargs = { + "config": self.config, + "inputs_embeds": inputs_embeds, + "attention_mask": attention_mask, + "past_key_values": past_key_values, + "position_ids": position_ids, + } + mask_creation_functions = { + "full_attention": lambda: create_causal_mask(**mask_kwargs), + "sliding_attention": lambda: create_sliding_window_causal_mask(**mask_kwargs), + } + causal_mask_mapping = {} + for layer_type in set(self.config.layer_types): + causal_mask_mapping[layer_type] = mask_creation_functions[layer_type]() + + hidden_states = inputs_embeds + position_embeddings = {} + for layer_type in set(self.config.layer_types): + position_embeddings[layer_type] = self.rotary_emb(hidden_states, position_ids, layer_type) + + for i, decoder_layer in enumerate(self.layers[: self.config.num_hidden_layers]): + hidden_states = decoder_layer( + hidden_states, + attention_mask=causal_mask_mapping[self.config.layer_types[i]], + position_embeddings=position_embeddings[self.config.layer_types[i]], + position_ids=position_ids, + past_key_values=past_key_values, + **kwargs, + ) + + hidden_states = self.norm(hidden_states) + + return MoeModelOutputWithPast( + last_hidden_state=hidden_states, + past_key_values=past_key_values if use_cache else None, + ) + + +class LagunaForCausalLM(Qwen2MoeForCausalLM): + def forward(self, **super_kwargs): + r""" + labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): + Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., + config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored + (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`. + """ + return super().forward(**super_kwargs) + + +__all__ = [ + "LagunaConfig", + "LagunaForCausalLM", + "LagunaModel", + "LagunaPreTrainedModel", +] diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/__init__.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b80f7d13aef410fb8165c6688b09c38b9736864 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/__init__.py @@ -0,0 +1,31 @@ +# Copyright 2024 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from typing import TYPE_CHECKING + +from ...utils import _LazyModule +from ...utils.import_utils import define_import_structure + + +if TYPE_CHECKING: + from .configuration_siglip import * + from .image_processing_pil_siglip import * + from .image_processing_siglip import * + from .modeling_siglip import * + from .processing_siglip import * + from .tokenization_siglip import * +else: + import sys + + _file = globals()["__file__"] + sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__) diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/configuration_siglip.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/configuration_siglip.py new file mode 100644 index 0000000000000000000000000000000000000000..69f5fba89f1e0dbd6dea6a7082fbb0947eb54c27 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/configuration_siglip.py @@ -0,0 +1,153 @@ +# Copyright 2024 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Siglip model configuration""" + +from huggingface_hub.dataclasses import strict + +from ...configuration_utils import PreTrainedConfig +from ...utils import auto_docstring, logging + + +logger = logging.get_logger(__name__) + + +@auto_docstring(checkpoint="google/siglip-base-patch16-224") +@strict +class SiglipTextConfig(PreTrainedConfig): + r""" + Example: + + ```python + >>> from transformers import SiglipTextConfig, SiglipTextModel + + >>> # Initializing a SiglipTextConfig with google/siglip-base-patch16-224 style configuration + >>> configuration = SiglipTextConfig() + + >>> # Initializing a SiglipTextModel (with random weights) from the google/siglip-base-patch16-224 style configuration + >>> model = SiglipTextModel(configuration) + + >>> # Accessing the model configuration + >>> configuration = model.config + ```""" + + model_type = "siglip_text_model" + base_config_key = "text_config" + + vocab_size: int = 32000 + hidden_size: int = 768 + intermediate_size: int = 3072 + num_hidden_layers: int = 12 + num_attention_heads: int = 12 + max_position_embeddings: int = 64 + hidden_act: str = "gelu_pytorch_tanh" + layer_norm_eps: float = 1e-6 + attention_dropout: float | int = 0.0 + # This differs from `CLIPTokenizer`'s default and from openai/siglip + # See https://github.com/huggingface/transformers/pull/24773#issuecomment-1632287538 + pad_token_id: int | None = 1 + bos_token_id: int | None = 49406 + eos_token_id: int | list[int] | None = 49407 + projection_size: int | None = None + + def __post_init__(self, **kwargs): + self.projection_size = self.projection_size if self.projection_size is not None else self.hidden_size + super().__post_init__(**kwargs) + + +@auto_docstring(checkpoint="google/siglip-base-patch16-224") +@strict +class SiglipVisionConfig(PreTrainedConfig): + r""" + Example: + + ```python + >>> from transformers import SiglipVisionConfig, SiglipVisionModel + + >>> # Initializing a SiglipVisionConfig with google/siglip-base-patch16-224 style configuration + >>> configuration = SiglipVisionConfig() + + >>> # Initializing a SiglipVisionModel (with random weights) from the google/siglip-base-patch16-224 style configuration + >>> model = SiglipVisionModel(configuration) + + >>> # Accessing the model configuration + >>> configuration = model.config + ```""" + + model_type = "siglip_vision_model" + base_config_key = "vision_config" + + hidden_size: int = 768 + intermediate_size: int = 3072 + num_hidden_layers: int = 12 + num_attention_heads: int = 12 + num_channels: int = 3 + image_size: int | list[int] | tuple[int, int] = 224 + patch_size: int | list[int] | tuple[int, int] = 16 + hidden_act: str = "gelu_pytorch_tanh" + layer_norm_eps: float = 1e-6 + attention_dropout: float | int = 0.0 + + +@auto_docstring(checkpoint="google/siglip-base-patch16-224") +@strict +class SiglipConfig(PreTrainedConfig): + r""" + Example: + + ```python + >>> from transformers import SiglipConfig, SiglipModel + + >>> # Initializing a SiglipConfig with google/siglip-base-patch16-224 style configuration + >>> configuration = SiglipConfig() + + >>> # Initializing a SiglipModel (with random weights) from the google/siglip-base-patch16-224 style configuration + >>> model = SiglipModel(configuration) + + >>> # Accessing the model configuration + >>> configuration = model.config + + >>> # We can also initialize a SiglipConfig from a SiglipTextConfig and a SiglipVisionConfig + >>> from transformers import SiglipTextConfig, SiglipVisionConfig + + >>> # Initializing a SiglipText and SiglipVision configuration + >>> config_text = SiglipTextConfig() + >>> config_vision = SiglipVisionConfig() + + >>> config = SiglipConfig(text_config=config_text, vision_config=config_vision) + ```""" + + model_type = "siglip" + sub_configs = {"text_config": SiglipTextConfig, "vision_config": SiglipVisionConfig} + + text_config: dict | PreTrainedConfig | None = None + vision_config: dict | PreTrainedConfig | None = None + initializer_factor: float = 1.0 + + def __post_init__(self, **kwargs): + if self.text_config is None: + self.text_config = SiglipTextConfig() + logger.info("`text_config` is `None`. Initializing the `SiglipTextConfig` with default values.") + elif isinstance(self.text_config, dict): + self.text_config = SiglipTextConfig(**self.text_config) + + if self.vision_config is None: + self.vision_config = SiglipVisionConfig() + logger.info("`vision_config` is `None`. initializing the `SiglipVisionConfig` with default values.") + elif isinstance(self.vision_config, dict): + self.vision_config = SiglipVisionConfig(**self.vision_config) + + super().__post_init__(**kwargs) + + +__all__ = ["SiglipConfig", "SiglipTextConfig", "SiglipVisionConfig"] diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/processing_siglip.py b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/processing_siglip.py new file mode 100644 index 0000000000000000000000000000000000000000..0e554b22ce3241a056880faece92515460b63c81 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/siglip/processing_siglip.py @@ -0,0 +1,28 @@ +# Copyright 2024 The HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Image/Text processor class for SigLIP. +""" + +from ...processing_utils import ProcessorMixin +from ...utils import auto_docstring + + +@auto_docstring +class SiglipProcessor(ProcessorMixin): + def __init__(self, image_processor, tokenizer): + super().__init__(image_processor, tokenizer) + + +__all__ = ["SiglipProcessor"] diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_015000.pt b/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_015000.pt new file mode 100644 index 0000000000000000000000000000000000000000..d0f8085de88fd94a9e76374e558675d3a2726824 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_015000.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b567178986137e3893f3982e1fbf2e5213b97102692fa7a551ec536c23beb47d +size 927700322 diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_023000.pt b/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_023000.pt new file mode 100644 index 0000000000000000000000000000000000000000..505bbeb7499042ab8e2d8ac51dbd0d976d77a331 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_023000.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f92adceed4d126ef91c5b14243d128d7c913c65be70b81ba879ec25827d7a23 +size 927700322 diff --git a/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_143000.pt b/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_143000.pt new file mode 100644 index 0000000000000000000000000000000000000000..35befdee6b2b3f897299924054e8e03cf48e0768 --- /dev/null +++ b/LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_143000.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4a010d76018fa5f9a1c1ecb0985d97772dc90c95a06548d44ad69765a0adb0d3 +size 927700322