Upload folder using huggingface_hub

graders/aggregate.py

@@ -88,7 +88,7 @@ class AggregateGrader:
                 "(fid=%.4f eff=%.4f noise=%.4f cstr=%.4f)",
                 fidelity_score, efficiency_score, noise_score, constraints_score,
             )
-            return 0.0
+            return 0.0001
 
         # Weighted sum
         weighted_sum = (
@@ -102,7 +102,7 @@ class AggregateGrader:
         # cannot score highly from efficiency/noise alone.
         aggregate = weighted_sum * fidelity_score
 
-        aggregate = float(max(0.0, min(1.0, aggregate)))
+        aggregate = float(max(0.0001, min(0.9999, aggregate)))
 
         logger.debug(
             "Aggregate: %.4f (fid=%.4f eff=%.4f noise=%.4f cstr=%.4f, "

inference.py

@@ -99,56 +99,136 @@ def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> No
 # System prompt for the LLM
 # ---------------------------------------------------------------------------
 
-SYSTEM_PROMPT = textwrap.dedent("""\
-    You are an expert quantum circuit designer. You are interacting with an RL environment
-    that lets you build quantum circuits step by step.
-    AVAILABLE ACTIONS (respond with valid JSON only):
-    1. ADD a gate:
-       {"action_type": "ADD", "gate": "<H|X|CNOT|RX|RZ>", "qubits": [<int>, ...], "parameter": <float or null>}
-       - H, X: single-qubit gates, qubits = [q]
-       - CNOT: two-qubit gate, qubits = [control, target]
-       - RX, RZ: parametric single-qubit gates, qubits = [q], parameter = angle in radians
-    2. REMOVE the last gate:
-       {"action_type": "REMOVE", "qubits": []}
-       Note: Yields +0.05 bonus if depth decreases with no fidelity loss. Yields -0.05 penalty if fidelity drops.
-    3. SWAP two qubits:
-       {"action_type": "SWAP", "qubits": [q1, q2]}
-       Note: Yields -0.02 penalty per SWAP since it represents real hardware routing overhead.
-    4. PARAM -- tune the last parametric gate:
-       {"action_type": "PARAM", "qubits": [], "parameter": <float>}
-    5. STOP -- end the episode:
-       {"action_type": "STOP", "qubits": []}
-    RULES:
-    - Respond with ONLY the JSON object, nothing else.
-    - Maximize fidelity to the target state while minimizing circuit depth.
-    - Consider REMOVE to revert a bad step to avoid depth penalties, or SWAP to map qubits.
-    - Respect any hardware connectivity constraints described in the observation.
-    - All episodes end at 15 steps max.
-""")
+SYSTEM_PROMPT = textwrap.dedent("""
+You are an expert quantum circuit optimization agent.
+
+You are NOT a pattern generator.
+You MUST behave as a decision-making optimizer that improves the circuit step-by-step.
+
+Your goal:
+Maximize fidelity to the target while minimizing circuit depth and noise impact.
+
+---
+
+AVAILABLE ACTIONS (respond with valid JSON only):
+
+1. ADD:
+{"action_type": "ADD", "gate": "<H|X|CNOT|RX|RZ>", "qubits": [<int>, ...], "parameter": <float or null>}
+
+2. REMOVE:
+{"action_type": "REMOVE", "qubits": []}
+
+3. SWAP:
+{"action_type": "SWAP", "qubits": [q1, q2]}
+
+4. PARAM:
+{"action_type": "PARAM", "qubits": [], "parameter": <float>}
+
+5. STOP:
+{"action_type": "STOP", "qubits": []}
+
+---
+
+CRITICAL DECISION PROCESS (YOU MUST FOLLOW THIS INTERNALLY):
+
+Step 1: Understand the target
+- What gates are required? (e.g., CNOT, RX, RZ)
+- Are parameters needed? (angles like π/3, π/4)
+
+Step 2: Analyze current circuit
+- What is already correct?
+- What is missing?
+- What is wrong or unnecessary?
+
+Step 3: Evaluate improvement
+- Which action will MOST increase fidelity?
+- Will adding this gate help or hurt under noise?
+- Is circuit becoming too deep?
+
+Step 4: Choose action strategically
+- Prefer actions that move toward target structure
+- Avoid random or repeated gates
+- Use parametric gates (RX, RZ) when precise tuning is required
+
+---
+
+STRICT RULES:
 
+- DO NOT repeat the same useless pattern (e.g., H → CNOT blindly).
+- DO NOT use STOP unless:
+  - Fidelity is already high (>0.95), OR
+  - No further improvement is possible.
+- For unitary/parametric tasks:
+  - You MUST use RX/RZ gates with meaningful parameters.
+  - Avoid using H unless clearly useful.
+- Prefer minimal circuits (depth matters due to noise).
+- If a step reduces fidelity, consider REMOVE.
+
+---
+
+ANTI-PATTERN WARNING (VERY IMPORTANT):
+
+If you find yourself repeating:
+H → CNOT → STOP
+
+You are WRONG.
+
+Re-evaluate the task and choose a better action.
+
+---
+
+OUTPUT FORMAT:
+
+Return ONLY the best action as JSON:
+{
+  "action_type": "...",
+  "gate": "...",
+  "qubits": [...],
+  "parameter": ...
+}
+""")
 
 # ---------------------------------------------------------------------------
 # LLM interaction
 # ---------------------------------------------------------------------------
 
 def build_user_prompt(obs_data: Dict[str, Any], step: int, history: List[str]) -> str:
-    """Build a user prompt from the current observation."""
-    history_block = "\n".join(history[-5:]) if history else "None"
-    return textwrap.dedent(f"""\
-        Step: {step}
-        Task: {obs_data.get('target_description', 'unknown')}
-        Qubits: {obs_data.get('num_qubits', 2)}
-        Current fidelity: {obs_data.get('fidelity', 0.0):.4f}
-        Current depth: {obs_data.get('depth', 0)}
-        Gate count: {obs_data.get('gate_count', 0)}
-        Noise estimate: {obs_data.get('noise_estimate', 0.0):.4f}
-        Score: {obs_data.get('score', 0.0):.4f}
-        Valid actions: {obs_data.get('valid_actions', [])}
-        Steps remaining: {obs_data.get('max_steps', 20) - obs_data.get('steps_taken', 0)}
-        Current circuit gates: {json.dumps(obs_data.get('circuit_gates', []))}
-        Recent history:
-        {history_block}
-        Choose your next action (JSON only):
+    """Optimized decision-making prompt (low tokens + high control)."""
+
+    # 🔹 Compact circuit (token-efficient)
+    circuit = [f"{g['gate']}({','.join(map(str, g['qubits']))})"
+               for g in obs_data.get("circuit_gates", [])]
+
+    # 🔹 Short history (avoid token waste)
+    history_block = "\n".join(history[-2:]) if history else "None"
+
+    return textwrap.dedent(f"""
+    TASK:
+    {obs_data.get('target_description', 'unknown')}
+
+    STATE:
+    Fidelity={obs_data.get('fidelity', 0.0):.3f}, Score={obs_data.get('score', 0.0):.3f}
+    Depth={obs_data.get('depth', 0)}, Steps_left={obs_data.get('max_steps', 20) - obs_data.get('steps_taken', 0)}
+
+    CIRCUIT:
+    {circuit if circuit else "empty"}
+
+    RECENT:
+    {history_block}
+
+    THINK:
+    1. What is the TARGET structure? (e.g., CNOT, RY, RZ)
+    2. What is MISSING from current circuit?
+    3. Will next step INCREASE fidelity?
+
+    RULES:
+    - Do NOT repeat useless gates
+    - Do NOT use STOP unless fidelity > 0.9
+    - Use RY/RZ for parametric/unitary tasks
+    - Prefer minimal depth (noise penalty)
+
+    OUTPUT:
+    Return ONLY one JSON action.
     """)
 
 
@@ -288,7 +368,7 @@ async def run_task(
 
         # Final score = aggregate score from the environment
         score = obs_data.get("score", 0.0)
-        score = min(max(score, 0.0), 1.0)
+        score = min(max(score, 0.0001), 0.9999)
         success = obs_data.get("fidelity", 0.0) >= SUCCESS_FIDELITY
 
     finally:

server/my_env_environment.py

@@ -669,7 +669,7 @@ class QuantumCircuitEnvironment(Environment):
             aggregate *= max(0.3, 1.0 - penalty)
 
         # Final clamp
-        aggregate = max(0.0, min(1.0, aggregate))
+        aggregate = max(0.0001, min(0.9999, aggregate))
         assert 0.0 <= aggregate <= 1.0, f"Aggregate score out of range: {aggregate}"
 
         return {