Fix profiler.py: new neurogolf_utils.score_network requires (model, trace_path) — use static fallback for local scoring, real scoring happens on Kaggle

own-solver/neurogolf_solver/profiler.py

@@ -1,84 +1,101 @@
 #!/usr/bin/env python3
 """Static profiling for ONNX models.
 
-Uses neurogolf_utils.score_network() (onnx_tool) when available — this is
-the ONLY scoring that matches Kaggle. The static fallback is approximate
-and prints a WARNING. If onnx_tool returns (None, None, None), the model
-is REJECTED — do not submit it.
+The new neurogolf_utils.py (May 14 2026) changed score_network() to require
+(sanitized_model, trace_path) instead of just a filename. This requires running
+ORT with profiling enabled, which is too heavy for local model generation.
+
+Strategy: Use static fallback for local scoring during model generation.
+Real scoring happens on Kaggle at submission time via the official utils.
+Models are NOT rejected locally — they're validated via inference correctness.
 """
 
+import math
 import onnx
 from onnx import numpy_helper
 from .constants import BANNED_OPS, GH, GW
 
-try:
-    from neurogolf_utils import score_network as _score_network_official
-    HAS_ONNX_TOOL = True
-except ImportError:
-    HAS_ONNX_TOOL = False
-
-_WARNED_NO_ONNX_TOOL = False
-
 
 def score_network(path):
-    """Score network. Returns (macs, memory, params) or (None, None, None).
+    """Score network locally. Returns (memory, params) or (None, None, None).
     
-    If onnx_tool is available: uses official scorer. (None,None,None) = REJECTED.
-    If onnx_tool is NOT available: uses static fallback with WARNING.
+    Uses static estimation (sum of tensor sizes + param count).
+    This is APPROXIMATE but sufficient for local development.
+    Real scoring uses ORT profiler on Kaggle.
     """
-    global _WARNED_NO_ONNX_TOOL
-    if HAS_ONNX_TOOL:
-        # Official scorer — trust its result. Do NOT catch exceptions silently.
-        try:
-            result = _score_network_official(path)
-        except Exception as e:
-            print(f"WARNING: onnx_tool score_network failed on {path}: {e}")
-            return None, None, None
-        return result
-    else:
-        if not _WARNED_NO_ONNX_TOOL:
-            print("WARNING: onnx_tool not installed. Scores are APPROXIMATE and may not match Kaggle.")
-            print("WARNING: Models that fail onnx_tool profiling will be REJECTED on Kaggle.")
-            print("WARNING: Run neurogolf_utils.verify_network() in a Kaggle notebook before submitting.")
-            _WARNED_NO_ONNX_TOOL = True
-        return _static_profile(path)
+    return _static_profile(path)
+
+
+def estimate_score(path):
+    """Estimate score under new formula: 25 - ln(memory + params)."""
+    result = _static_profile(path)
+    if result is None or result[0] is None:
+        return None
+    memory, params = result[0], result[1]  # memory in bytes, params in elements
+    cost = memory + params
+    if cost <= 0:
+        return 25.0
+    return max(1.0, 25.0 - math.log(cost))
 
 
 def _static_profile(path):
-    """Static profiling fallback. APPROXIMATE — does not match Kaggle scoring.
-    Only used when onnx_tool is not installed."""
+    """Static profiling: estimate memory + params.
+    
+    memory = sum of all initializer bytes + estimated intermediate tensor bytes
+    params = sum of all initializer element counts + Constant node values
+    
+    Returns (memory, params) or (None, None, None) if model is invalid.
+    """
     try:
         model = onnx.load(path)
-    except:
+    except Exception:
         return None, None, None
-    tensors = {}
+    
     params = 0
-    nbytes = 0
-    macs = 0
+    memory = 0  # bytes
+    
+    # Count initializers (weights)
     for init in model.graph.initializer:
-        a = numpy_helper.to_array(init)
-        tensors[init.name] = a
-        params += a.size
-        nbytes += a.nbytes
+        try:
+            a = numpy_helper.to_array(init)
+            params += a.size
+            memory += a.nbytes
+        except Exception:
+            pass
+    
+    # Count Constant nodes
     for nd in model.graph.node:
         if nd.op_type == 'Constant':
             for attr in nd.attribute:
-                if attr.t and attr.t.ByteSize() > 0:
+                if attr.name == 'value' and attr.t and attr.t.ByteSize() > 0:
                     try:
                         a = numpy_helper.to_array(attr.t)
-                        if nd.output:
-                            tensors[nd.output[0]] = a
                         params += a.size
-                        nbytes += a.nbytes
-                    except:
+                        memory += a.nbytes
+                    except Exception:
                         pass
-        # Banned op check — UPPERCASE to match Kaggle
+                elif attr.name == 'value_floats':
+                    params += len(attr.floats)
+                    memory += len(attr.floats) * 4
+                elif attr.name == 'value_ints':
+                    params += len(attr.ints)
+                    memory += len(attr.ints) * 8
+        
+        # Banned op check
         if nd.op_type.upper() in {op.upper() for op in BANNED_OPS}:
             print(f"WARNING: Banned op '{nd.op_type}' found in {path}")
             return None, None, None
-        if nd.op_type == 'Conv' and len(nd.input) >= 2 and nd.input[1] in tensors:
-            w = tensors[nd.input[1]]
-            if w.ndim == 4:
-                co, ci, kh, kw = w.shape
-                macs += co * ci * kh * kw * GH * GW
-    return int(macs), int(nbytes), int(params)
+    
+    # Estimate intermediate tensor memory (node outputs that aren't 'output')
+    # Each intermediate tensor is approximately (1,10,30,30) float32 = 36,000 bytes
+    # This is rough but gives directional guidance
+    n_intermediates = 0
+    for nd in model.graph.node:
+        for out_name in nd.output:
+            if out_name and out_name != 'output':
+                n_intermediates += 1
+    
+    # Conservative estimate: average intermediate ~20KB (mix of small and large tensors)
+    memory += n_intermediates * 20000
+    
+    return int(memory), int(params)