Downloads · 30 days
0
EdwardoSunny/ttt-discover-v3-qwen3-8b-ac1-s2-step26
ttt-discover-v3-qwen3-8b-ac1-s2-step26 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 25 (0-indexed). Strict upstream eval parity: 1100s hard…
Downloads · 30 days
0
Access
Public
Updated Jul 11, 2026
Repo size
349 MB
Likes
0
Public
Click a slice to open those files.
.safetensors349 MB · 100%
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 25 (0-indexed). Strict upstream eval parity:
1100s hard kill, verbatim prompts/entrypoints, group 64x8, T=1.0, kl 0.1.
{
"step": 25,
"progress/batch": 25,
"optim/lr": 4e-05,
"progress/done_frac": 0.52,
"puct/buffer_size": 408,
"puct/sampled_size": 8,
"puct/T": 12800,
"puct/scale_last": 0.5741283121188268,
"puct/buffer_value/mean": -1.5315090965123408,
"puct/buffer_value/std": 0.09741650822966827,
"puct/buffer_value/min": -2.0797874683482562,
"puct/buffer_value/max": -1.5056591562294295,
"puct/buffer_timestep/mean": 11.745098039215685,
"puct/buffer_timestep/std": 7.36404390518193,
"puct/buffer_timestep/min": -1.0,
"puct/buffer_timestep/max": 24.0,
"puct/buffer_construction_len/mean": 1147.0343137254902,
"puct/buffer_construction_len/std": 812.7975134325744,
"puct/buffer_construction_len/min": 1000.0,
"puct/buffer_construction_len/max": 7850.0,
"puct/sampled_value/mean": -1.5056595151425551,
"puct/sampled_value/std": 2.3449345108746799e-07,
"puct/sampled_value/min": -1.505659817571757,
"puct/sampled_value/max": -1.5056591562294295,
"puct/sampled_timestep/mean": 24.0,
"puct/sampled_timestep/std": 0.0,
"puct/sampled_timestep/min": 24.0,
"puct/sampled_timestep/max": 24.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": 5248.889454841614,
"env/all/ac_tokens_per_turn": 8697.982421875,
"env/all/ob_tokens_per_turn": 3366.375,
"env/all/turns_per_episode": 1.0,
"env/all/total_episodes": 512,
"env/all/total_turns": 512,
"env/all/total_ac_tokens": 4453367,
"env/all/total_ob_tokens": 1723584,
"env/all/time/sampling_mean": 317.1542122969404,
"env/all/time/sampling_max": 421.60493898391724,
"env/all/time/env_step_mean": 2391.641982014291,
"env/all/time/env_step_max": 4841.031892776489,
"env/all/reward/mean": 0.5421877610534485,
"env/all/reward/max": 0.6641617611125725,
"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.5421877610534485,
"env/all/correctness": 0.84765625,
"env/all/correctness/min": 0.0,
"env/all/correctness/max": 1.0,
"env/all/raw_score": 1.5913489173820765,
"env/all/raw_score/min": 1.5056572839773694,
"env/all/raw_score/max": 5.577880315927836,
"env/all/initial_raw_score": -1.5056595151425554,
"env/all/initial_raw_score/min": -1.505659817571757,
"env/all/initial_raw_score/max": -1.5056591562294295,
"env/all/msg": "Success; raw_score=1.50565915622943",
"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 refines the previous strategy by improving LP constraint selection, \n enhancing perturbation methods, and increasing search iterations for better convergence.\n \"\"\"\n np.random.seed(seed)\n deadline = time.time() + budget_s - 10\n\n # Start from known best construction if it exists\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 # Use a Gaussian-based initial sequence for better exploration\n initial_n = 500\n base = np.random.normal(loc=0.0, scale=0.1, size=initial_n)\n base = np.clip(base, 0.0, 1000.0)\n sum_base = np.sum(base)\n scale_factor = 0.1 / sum_base if sum_base > 0 else 0.1\n initial_sequences = [[max(0.0, x * scale_factor) for x in base]]\n best_sequence = initial_sequences[0].copy()\n \n current_sequence = best_sequence.copy()\n best_score = float('inf')\n random_walk_prob = 0.15 # Higher initial probability for exploration\n\n def get_good_direction_to_move_into(sequence):\n \"\"\"Computes a better sequence using adaptive constraint selection with dynamic threshold.\"\"\"\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 # Use a lower threshold to include more constraints\n threshold = 0.1 * max_b_val\n tight_positions = np.where(conv >= threshold)[0]\n if not tight_positions.size:\n tight_positions = np.arange(2 * n - 1)\n # Solve LP with enhanced constraint selection and solver adjustments\n g_fun = solve_convolution_lp(sequence, max_b_val, tight_positions)\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 # Use more iterations in golden-section search\n def objective(t):\n new_seq = [ (1 - t) * x + t * y for x, y in zip(sequence, g_fun) ]\n return evaluate_sequence(new_seq)\n\n # Find optimal t between 0 and 1\n low = 0.0\n high = 1.0\n for _ in range(200): # Increased iterations for better convergence\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_fun) ]\n return new_seq\n\n def solve_convolution_lp(f_sequence, rhs, tight_positions):\n \"\"\"Solves LP with enhanced constraint selection and solver adjustments.\"\"\"\n n = len(f_sequence)\n if n == 0:\n return None\n\n # Variables\n g = cp.Variable(n, nonneg=True)\n # Objective: maximize sum(g_j), equivalent to minimizing -sum(g_j)\n objective = cp.Minimize(-cp.sum(g))\n\n # Constraints: ensure max(convolution) <= rhs\n constraints = []\n # Limit the number of constraints to reduce solve time\n selected_positions = tight_positions[:] # Include all tight positions\n for k in selected_positions:\n # Coefficients for the constraint: sum_{j=0}^{n-1} f[i] * g[j] <= rhs\n coeff = np.zeros(n)\n for j in range(n):\n i = k - 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.SCS, 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 \"\"\"Perturbation with structured strategies for local minima escape.\"\"\"\n n = len(seq)\n if n == 0:\n return None\n\n conv = np.convolve(seq, seq)\n # Select top 70 indices with highest convolution values for targeted changes\n top_indices = np.argsort(conv)[-70:]\n indices = np.random.choice(top_indices, size=min(70, len(top_indices)), replace=False)\n indices = [min(idx, len(seq)-1) for idx in indices]\n # Occasionally perturb a random element\n if np.random.rand() < 0.2:\n random_idx = np.random.randint(0, len(seq))\n indices.append(random_idx)\n # Use adaptive scaling based on sequence properties\n scale = 0.1 * np.std(seq)\n for idx in indices:\n # Add random variation with varying scale\n new_val = max(0.0, seq[idx] + np.random.normal(0, scale))\n seq = [new_val if i == idx else seq[i] for i in range(len(seq))]\n return seq\n\n def random_walk(seq):\n \"\"\"Adds small random perturbations to all elements.\"\"\"\n scale = 0.1 * 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 \"\"\"Strategically expand the sequence to explore new dimensions.\"\"\"\n n = len(seq)\n if n >= 1500: # Increase limit for better exploration\n return seq.copy()\n # Add a new element with value similar to the spread of current elements\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 # Normalize to ensure sum remains >= 0.01\n new_sum = np.sum(new_seq)\n if new_sum > 0.0:\n new_seq = [x / new_sum for x in new_seq]\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 sequence if possible\n if len(current_sequence) < 1500:\n current_sequence = expand_sequence(current_sequence)\n print(f\"Expanded sequence to length {len(current_sequence)}\")\n else:\n current_sequence = perturb_sequence(current_sequence)\n else:\n current_sequence = h_function\n\n # Adjust random walk probability to explore less as solution improves\n if random_walk_prob > 0.05:\n random_walk_prob *= 0.995\n\n # Occasionally try random walk for exploration\n if np.random.rand() < random_walk_prob:\n current_sequence = random_walk(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": 317.1542122969404,
"env/all/time/policy/min": 162.6450207233429,
"env/all/time/policy/max": 421.60493898391724,
"env/all/time/env_step": 2391.641982014291,
"env/all/time/env_step/min": 0.7556514739990234,
"env/all/time/env_step/max": 4841.031892776489,
"env/all/time/reward_compute": 7.203780114650726e-07,
"env/all/time/reward_compute/min": 2.1979212760925293e-07,
"env/all/time/reward_compute/max": 1.7844140529632568e-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.014419365674257278,
"advantage/min": -1.0,
"advantage/max": 2.2227964401245117,
"time/assemble_training_data": 5.853636264801025,
"time/kl_vs_base": 88.36962652206421,
"kl_policy_base": 0.0009062764002010226,
"time/train": 583.0878283977509,
"time/save_checkpoint": 19.204123973846436,
"time/total": 5947.101986646652
}
[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