Downloads · 30 days
0
EdwardoSunny/ttt-discover-v3-qwen3-8b-ac1-s2-step31
ttt-discover-v3-qwen3-8b-ac1-s2-step31 is a machine learning model from EdwardoSunny. Use it for the machine learning task on the model card, and read the license before you ship it in a product.
LoRA adapter (rank 32, all-linear) from the upstream-faithful local reproduction of TTT-Discover on autoresearch-bench ac1. Checkpoint saved after training step 30 (0-indexed). Strict upstream eval parity: 1100s hard…
Downloads · 30 days
0
Access
Public
Updated Jul 11, 2026
Repo size
354 MB
Likes
0
Public
Click a slice to open those files.
.safetensors349 MB · 99%
From the Hugging Face model README
LoRA adapter (rank 32, all-linear) from the upstream-faithful local
reproduction of TTT-Discover on autoresearch-bench ac1. Checkpoint saved
after training step 30 (0-indexed). Strict upstream eval parity:
1100s hard kill, verbatim prompts/entrypoints, group 64x8, T=1.0, kl 0.1.
{
"step": 30,
"progress/batch": 30,
"optim/lr": 4e-05,
"progress/done_frac": 0.62,
"puct/buffer_size": 488,
"puct/sampled_size": 8,
"puct/T": 15360,
"puct/scale_last": 0.5741320882344796,
"puct/buffer_value/mean": -1.5272710884863463,
"puct/buffer_value/std": 0.08958706337577058,
"puct/buffer_value/min": -2.0797874683482562,
"puct/buffer_value/max": -1.5056553801137766,
"puct/buffer_timestep/mean": 14.245901639344263,
"puct/buffer_timestep/std": 8.806956523308148,
"puct/buffer_timestep/min": -1.0,
"puct/buffer_timestep/max": 29.0,
"puct/buffer_construction_len/mean": 1122.9303278688524,
"puct/buffer_construction_len/std": 745.1854148618605,
"puct/buffer_construction_len/min": 1000.0,
"puct/buffer_construction_len/max": 7850.0,
"puct/sampled_value/mean": -1.505656205568286,
"puct/sampled_value/std": 4.7275189195916896e-07,
"puct/sampled_value/min": -1.50565652755856,
"puct/sampled_value/max": -1.5056553801137766,
"puct/sampled_timestep/mean": 29.0,
"puct/sampled_timestep/std": 0.0,
"puct/sampled_timestep/min": 29.0,
"puct/sampled_timestep/max": 29.0,
"puct/sampled_construction_len/mean": 1000.0,
"puct/sampled_construction_len/std": 0.0,
"puct/sampled_construction_len/min": 1000.0,
"puct/sampled_construction_len/max": 1000.0,
"time/sampling": 5511.83163356781,
"env/all/ac_tokens_per_turn": 8230.0390625,
"env/all/ob_tokens_per_turn": 3256.375,
"env/all/turns_per_episode": 1.0,
"env/all/total_episodes": 512,
"env/all/total_turns": 512,
"env/all/total_ac_tokens": 4213780,
"env/all/total_ob_tokens": 1667264,
"env/all/time/sampling_mean": 510.0042235702276,
"env/all/time/sampling_max": 721.9005255699158,
"env/all/time/env_step_mean": 2572.7449057390913,
"env/all/time/env_step_max": 4809.555538415909,
"env/all/reward/mean": 0.5267352463277304,
"env/all/reward/max": 0.66416284139112,
"env/all/reward/min": 0.0,
"env/all/format": 1.0,
"env/all/format/min": 1.0,
"env/all/format/max": 1.0,
"env/all/reward": 0.5267352463277304,
"env/all/correctness": 0.802734375,
"env/all/correctness/min": 0.0,
"env/all/correctness/max": 1.0,
"env/all/raw_score": 2.0377187579179017,
"env/all/raw_score/min": 1.5056548349856866,
"env/all/raw_score/max": 212.85459709678875,
"env/all/initial_raw_score": -1.5056562055682865,
"env/all/initial_raw_score/min": -1.50565652755856,
"env/all/initial_raw_score/max": -1.5056553801137766,
"env/all/msg": "Success; raw_score=1.5056553730992588",
"env/all/parsed_code": "```python\nimport time\nimport numpy as np\nimport cvxpy as cp\nimport copy\nimport random\nimport math\n\ndef propose_candidate(seed=42, budget_s=1000, **kwargs):\n \"\"\"\n Optimizes a sequence of non-negative coefficients to minimize the evaluation function.\n This approach uses a combination of LP-based optimization, gradient descent, and diverse perturbation methods with enhanced exploration and initialization strategies.\n \"\"\"\n np.random.seed(seed)\n deadline = time.time() + budget_s - 10\n\n # Start with a tailored initial sequence\n prev = globals().get(\"height_sequence_1\", None)\n if prev is not None and isinstance(prev, (list, np.ndarray)) and len(prev) > 0:\n best_sequence = list(np.asarray(prev, dtype=float))\n else:\n # Try a uniform initial sequence\n initial_n = 1000\n target_sum = np.sqrt(2 * initial_n)\n sequence = [target_sum / initial_n] * initial_n\n best_sequence = sequence.tolist()\n\n current_sequence = best_sequence[:]\n best_score = float('inf')\n\n def get_good_direction_to_move_into(sequence):\n \"\"\"Computes a better sequence using an LP-based approach with enhanced constraint selection.\"\"\"\n n = len(sequence)\n if n == 0:\n return None\n\n sum_sequence = np.sum(sequence)\n if sum_sequence <= 0.0:\n return None\n\n conv = np.convolve(sequence, sequence)\n max_b_val = np.max(conv)\n\n # Solve LP with enhanced constraint selection\n g_fun = solve_convolution_lp(sequence, max_b_val)\n if g_fun is None:\n return None\n\n sum_g = np.sum(g_fun)\n if sum_g <= 0.0:\n return None\n\n # Normalize g_fun to match current sequence's sum\n scaling_factor = sum_sequence / sum_g\n g_normalized = g_fun * scaling_factor\n\n # Find optimal step t via golden-section search\n def objective(t):\n new_seq = [ (1 - t) * x + t * y for x, y in zip(sequence, g_normalized) ]\n return evaluate_sequence(new_seq)\n\n # Golden-section search on t with more iterations\n low, high = 0.0, 1.0\n for _ in range(300): # increased from 200 to 300 iterations\n t1 = low + (high - low) / 3\n t2 = high - (high - low) / 3\n f1 = objective(t1)\n f2 = objective(t2)\n if f1 < f2:\n high = t2\n else:\n low = t1\n best_t = (low + high) / 2\n new_seq = [ (1 - best_t) * x + best_t * y for x, y in zip(sequence, g_normalized) ]\n return new_seq\n\n def solve_convolution_lp(f_sequence, rhs):\n \"\"\"Solves an LP problem with enhanced constraint selection.\"\"\"\n n = len(f_sequence)\n if n == 0:\n return None\n\n # Compute the convolution\n conv = np.convolve(f_sequence, f_sequence)\n # Select top k positions with highest convolution values\n k = min(50, len(conv)) # adjust based on sequence length\n tight_positions = np.argsort(conv)[-k:] # get indices of top k values\n tight_positions = np.sort(tight_positions) # ensure sorted\n\n # Variables\n g = cp.Variable(n, nonneg=True)\n # Objective: maximize sum(g)\n objective = cp.Maximize(cp.sum(g))\n\n # Constraints: ensure max(convolution) <= rhs\n constraints = []\n for k_pos in tight_positions:\n coeff = np.zeros(n)\n for j in range(n):\n i = k_pos - j\n if 0 <= i < n:\n coeff[j] = f_sequence[i]\n constraints.append(cp.sum(coeff * g) <= rhs)\n\n # Solve the LP with a more efficient solver\n problem = cp.Problem(objective, constraints)\n try:\n problem.solve(solver=cp.GLPK, verbose=False, eps=1e-6)\n if problem.status == cp.OPTIMAL:\n return g.value\n except:\n pass\n return None\n\n def perturb_sequence(seq):\n \"\"\"Perturbs the sequence to explore nearby regions of the search space.\"\"\"\n n_seq = len(seq)\n if n_seq == 0:\n return None\n\n conv = np.convolve(seq, seq)\n # Perturb the positions with the highest convolution values\n top_indices = np.argsort(conv)[-100:] # increase the number of indices\n indices = np.random.choice(top_indices, size=min(100, len(top_indices)), replace=False)\n indices = [min(idx, n_seq - 1) for idx in indices]\n\n # Occasionally perturb a random element\n if np.random.rand() < 0.2:\n random_idx = np.random.randint(0, n_seq)\n indices.append(random_idx)\n\n # Add random variation with adaptive scaling\n scale = 0.05 * np.std(seq)\n new_seq = seq[:]\n for idx in indices:\n new_val = max(0.0, seq[idx] + np.random.normal(0, scale))\n new_seq[idx] = new_val\n\n return new_seq\n\n def random_walk(seq):\n \"\"\"Random walk with small perturbations to nearby sequences.\"\"\"\n n_seq = len(seq)\n if n_seq == 0:\n return None\n\n scale = 0.05 * np.std(seq)\n new_seq = [max(0.0, x + np.random.normal(0, scale)) for x in seq]\n return new_seq\n\n def expand_sequence(seq):\n \"\"\"Expands the sequence with a new element, maintaining the target normalization.\"\"\"\n n = len(seq)\n if n >= 1500:\n return seq.copy()\n\n target_sum = np.sqrt(2 * (n + 1))\n val = np.mean(seq) + np.random.normal(0, 0.05) * np.std(seq)\n val = max(0.0, min(1000.0, val))\n new_seq = seq + [val]\n current_sum = np.sum(new_seq)\n scale = target_sum / current_sum\n new_seq = [x * scale for x in new_seq]\n return new_seq\n\n def gradient_descent_step(sequence):\n \"\"\"Performs a gradient descent step to minimize max(convolution).\"\"\"\n conv = np.convolve(sequence, sequence)\n max_index = np.argmax(conv)\n n = len(sequence)\n grad = np.zeros(n)\n epsilon = 1e-5\n for i in range(n):\n seq_pert = sequence.copy()\n seq_pert[i] += epsilon\n conv_pert = np.convolve(seq_pert, seq_pert)\n delta = conv_pert[max_index] - conv[max_index]\n grad[i] = delta / epsilon\n # Move opposite to gradient\n new_seq = sequence - 0.01 * grad\n # Ensure non-negative\n new_seq = np.clip(new_seq, 0, 1000)\n # Maintain sum\n sum_new = np.sum(new_seq)\n scale = np.sqrt(2 * n) / sum_new if sum_new > 0 else 1.0\n new_seq *= scale\n return new_seq\n\n while time.time() < deadline:\n # Try LP-based move\n h_function = get_good_direction_to_move_into(current_sequence)\n if h_function is None:\n # Expand the sequence if needed\n current_sequence = expand_sequence(current_sequence)\n print(f\"Expanded sequence to length {len(current_sequence)}\")\n else:\n current_sequence = h_function\n\n # Occasionally try random walk for diversity\n if np.random.rand() < 0.05:\n current_sequence = random_walk(current_sequence)\n\n # Try gradient descent step\n if np.random.rand() < 0.1:\n current_sequence = gradient_descent_step(current_sequence)\n\n try:\n curr_score = evaluate_sequence(current_sequence)\n if curr_score < best_score:\n best_score = curr_score\n best_sequence = current_sequence.copy()\n print(f\"New best: {best_score}\")\n except Exception:\n pass\n\n return [float(max(0.0, x)) for x in best_sequence]\n```",
"env/all/time/policy": 510.0042235702276,
"env/all/time/policy/min": 244.82191562652588,
"env/all/time/policy/max": 721.9005255699158,
"env/all/time/env_step": 2572.7449057390913,
"env/all/time/env_step/min": 0.787015438079834,
"env/all/time/env_step/max": 4809.555538415909,
"env/all/time/reward_compute": 9.140931069850922e-07,
"env/all/time/reward_compute/min": 2.2724270820617676e-07,
"env/all/time/reward_compute/max": 3.378838300704956e-06,
"env/all/by_group/frac_mixed": 1.0,
"env/all/by_group/frac_all_good": 0.0,
"env/all/by_group/frac_all_bad": 0.0,
"advantage/mean": 0.007907210849225521,
"advantage/min": -1.0,
"advantage/max": 2.0311594009399414,
"time/assemble_training_data": 5.499598741531372,
"time/kl_vs_base": 139.0424702167511,
"kl_policy_base": 0.001003035344183445,
"time/train": 1096.020914554596,
"time/save_checkpoint": 19.438137531280518,
"time/total": 6777.867040634155
}
[2026-07-09T06:24:18+00:00] job=1812630 node=node-14 ngpu=3 ntrain=1 replicas=2 flash_attn=no
[2026-07-09T09:14:17+00:00] job=1813129 node=node-28 ngpu=3 ntrain=1 replicas=2 flash_attn=yes
[2026-07-09T13:46:36+00:00] job=1813130 node=node-22 ngpu=6 ntrain=2 replicas=4 flash_attn=yes
[2026-07-11T14:04:05+00:00] job=1824338 node=node-1 ngpu=3 ntrain=1 replicas=2 flash_attn=yes