Add previously failing case, introduce stochastic gradient descent optimizer, make scale-invariant via initial hop distance calculation (#15)

* notes from testing

* wip

* compute hops to end and use as distance measure

* use hop distance as heuristic

* make parameters easier to load for gradient descent

* introduce lr velocity

* give sense of progress

* wip

* remove clamping

* gradient descent patches

* parameter adjustment

* stochastic optimization and new hyperparameters

* format

Author: seveibar

fixtures/jumper-graph-solver/jumper-graph-solver03.fixture.tsx

@@ -23,7 +23,7 @@ export default () => {
     innerColChannelPointCount: 3,
     innerRowChannelPointCount: 3,
     regionsBetweenPads: true,
-    orientation
+    orientation,
   })
 
   const graphWithConnections = createProblemFromBaseGraph({

fixtures/jumper-graph-solver/jumper-graph-solver05.fixture.tsx

@@ -0,0 +1,20 @@
+import { GenericSolverDebugger } from "@tscircuit/solver-utils/react"
+import { JumperGraphSolver } from "lib/JumperGraphSolver/JumperGraphSolver"
+import type { JPort, JRegion } from "lib/index"
+import inputData from "../../tests/jumper-graph-solver/jumper-graph-solver05-input.json"
+
+export default () => {
+  return (
+    <GenericSolverDebugger
+      createSolver={() =>
+        new JumperGraphSolver({
+          inputGraph: {
+            regions: inputData.graph.regions as JRegion[],
+            ports: inputData.graph.ports as unknown as JPort[],
+          },
+          inputConnections: inputData.connections,
+        })
+      }
+    />
+  )
+}

lib/HyperGraphSolver.ts

@@ -285,6 +285,14 @@ export class HyperGraphSolver<
    */
   routeSolvedHook(solvedRoute: SolvedRoute) {}
 
+  /**
+   * OPTIONALLY OVERRIDE THIS
+   *
+   * You can override this to perform actions when a new route begins, e.g.
+   * you may want to log or track which connection is being processed.
+   */
+  routeStartedHook(connection: Connection) {}
+
   ripSolvedRoute(solvedRoute: SolvedRoute) {
     for (const port of solvedRoute.path.map((candidate) => candidate.port)) {
       port.ripCount = (port.ripCount ?? 0) + 1
@@ -305,6 +313,7 @@ export class HyperGraphSolver<
     this.currentEndRegion = this.currentConnection.endRegion
     this.candidateQueue = new PriorityQueue<Candidate>()
     this.visitedPointsForCurrentConnection.clear()
+    this.routeStartedHook(this.currentConnection)
     for (const port of this.currentConnection.startRegion.ports) {
       this.candidateQueue.enqueue({
         port,

lib/JumperGraphSolver/JumperGraphSolver.ts

@@ -14,16 +14,25 @@ import { distance } from "@tscircuit/math-utils"
 import { computeDifferentNetCrossings } from "./computeDifferentNetCrossings"
 import { computeCrossingAssignments } from "./computeCrossingAssignments"
 
+export const JUMPER_GRAPH_SOLVER_DEFAULTS = {
+  portUsagePenalty: 0.06393718451067248,
+  portUsagePenaltySq: 0.06194817180037216,
+  crossingPenalty: 6.0761550028071145,
+  crossingPenaltySq: 0.1315528159128946,
+  ripCost: 40.00702225250195,
+  greedyMultiplier: 0.4316469416682083,
+}
+
 export class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
   UNIT_OF_COST = "distance"
 
-  portUsagePenalty = 0.197
-  portUsagePenaltySq = 0
-  crossingPenalty = 6.007
-  crossingPenaltySq = 0.111
-  override ripCost = 40
+  portUsagePenalty = JUMPER_GRAPH_SOLVER_DEFAULTS.portUsagePenalty
+  portUsagePenaltySq = JUMPER_GRAPH_SOLVER_DEFAULTS.portUsagePenaltySq
+  crossingPenalty = JUMPER_GRAPH_SOLVER_DEFAULTS.crossingPenalty
+  crossingPenaltySq = JUMPER_GRAPH_SOLVER_DEFAULTS.crossingPenaltySq
+  override ripCost = JUMPER_GRAPH_SOLVER_DEFAULTS.ripCost
   baseMaxIterations = 4000
-  additionalMaxIterationsPerConnection = 2000
+  additionalMaxIterationsPerConnection = 4000
 
   constructor(input: {
     inputGraph: HyperGraph | SerializedHyperGraph
@@ -35,7 +44,7 @@ export class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     additionalMaxIterationsPerConnection?: number
   }) {
     super({
-      greedyMultiplier: 0.45,
+      greedyMultiplier: JUMPER_GRAPH_SOLVER_DEFAULTS.greedyMultiplier,
       rippingEnabled: true,
       ...input,
     })
@@ -50,10 +59,52 @@ export class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     this.MAX_ITERATIONS =
       this.baseMaxIterations +
       input.inputConnections.length * this.additionalMaxIterationsPerConnection
+
+    this.populateDistanceToEndMaps()
+  }
+
+  private populateDistanceToEndMaps() {
+    // Get all unique end regions from connections
+    const endRegions = new Set(this.connections.map((c) => c.endRegion))
+
+    // For each end region, compute hop distances from all ports using BFS
+    for (const endRegion of endRegions) {
+      const regionDistanceMap = new Map<string, number>()
+      const queue: Array<{ region: JRegion; distance: number }> = []
+
+      regionDistanceMap.set(endRegion.regionId, 0)
+      queue.push({ region: endRegion as JRegion, distance: 0 })
+
+      while (queue.length > 0) {
+        const { region, distance: dist } = queue.shift()!
+
+        for (const port of region.ports) {
+          const otherRegion = (
+            port.region1 === region ? port.region2 : port.region1
+          ) as JRegion
+          if (!regionDistanceMap.has(otherRegion.regionId)) {
+            regionDistanceMap.set(otherRegion.regionId, dist + 1)
+            queue.push({ region: otherRegion, distance: dist + 1 })
+          }
+        }
+      }
+
+      // Populate each port's distanceToEndMap for this end region
+      for (const port of this.graph.ports) {
+        if (!port.distanceToEndMap) {
+          port.distanceToEndMap = {}
+        }
+        const d1 = regionDistanceMap.get(port.region1.regionId) ?? Infinity
+        const d2 = regionDistanceMap.get(port.region2.regionId) ?? Infinity
+        port.distanceToEndMap[endRegion.regionId] = Math.min(d1, d2)
+      }
+    }
   }
 
   override estimateCostToEnd(port: JPort): number {
-    return distance(port.d, this.currentEndRegion!.d.center)
+    const endRegionId = this.currentEndRegion!.regionId
+    const hopDistance = port.distanceToEndMap![endRegionId]!
+    return hopDistance
   }
   override getPortUsagePenalty(port: JPort): number {
     const ripCount = port.ripCount ?? 0
@@ -84,6 +135,8 @@ export class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
 
   override routeSolvedHook(solvedRoute: SolvedRoute) {}
 
+  override routeStartedHook(connection: Connection) {}
+
   override visualize(): GraphicsObject {
     return visualizeJumperGraphSolver(this)
   }

lib/types.ts

@@ -16,6 +16,12 @@ export type RegionPort = {
    * ports that are likely to block off connections
    */
   ripCount?: number
+
+  /**
+   * Optionally can be used by solvers to keep track of the distance to
+   * each end era.
+   */
+  distanceToEndMap?: Record<RegionId, number>
 }
 
 export type Region = {

scripts/hyper-parameter-optimization/evaluator.ts

@@ -0,0 +1,89 @@
+import { JumperGraphSolver } from "../../lib/JumperGraphSolver/JumperGraphSolver"
+import type { Parameters, EvaluationResult, SampleConfig } from "./types"
+import type { PregeneratedProblem } from "./problem-generator"
+
+/**
+ * Evaluates parameters on pregenerated problems.
+ * Uses structuredClone to avoid mutating the original problem data.
+ */
+export function evaluateParametersOnProblems(
+  params: Parameters,
+  problemsByConfig: Map<number, PregeneratedProblem[]>,
+  configs: SampleConfig[],
+  progressLabel?: string,
+): EvaluationResult {
+  let totalRouted = 0
+  let totalConnections = 0
+  let solvedCount = 0
+
+  for (let i = 0; i < configs.length; i++) {
+    const config = configs[i]
+    if (progressLabel) {
+      process.stdout.write(`\r${progressLabel}: ${i + 1}/${configs.length}`)
+    }
+
+    const problems = problemsByConfig.get(config.seed)
+    if (!problems) {
+      throw new Error(`No pregenerated problems for seed ${config.seed}`)
+    }
+
+    let bestRoutedFraction = 0
+    let solved = false
+
+    for (const { problem } of problems) {
+      // Use structuredClone to avoid mutating the original problem
+      const clonedProblem = structuredClone(problem)
+      const totalConns = clonedProblem.connections.length
+
+      const solver = new JumperGraphSolver({
+        inputGraph: {
+          regions: clonedProblem.regions,
+          ports: clonedProblem.ports,
+        },
+        inputConnections: clonedProblem.connections,
+        portUsagePenalty: params.portUsagePenalty,
+        crossingPenalty: params.crossingPenalty,
+        ripCost: params.ripCost,
+      })
+
+      // Apply additional parameters that aren't in constructor
+      ;(solver as any).portUsagePenaltySq = params.portUsagePenaltySq
+      ;(solver as any).crossingPenaltySq = params.crossingPenaltySq
+      ;(solver as any).greedyMultiplier = params.greedyMultiplier
+
+      solver.solve()
+
+      const routedFraction = solver.solvedRoutes.length / totalConns
+
+      if (solver.solved) {
+        solved = true
+        bestRoutedFraction = 1.0
+        break
+      } else if (routedFraction > bestRoutedFraction) {
+        bestRoutedFraction = routedFraction
+      }
+    }
+
+    // Estimate total connections from numCrossings
+    const estimatedConns = Math.ceil(
+      (1 + Math.sqrt(1 + 8 * config.numCrossings)) / 2,
+    )
+    totalConnections += estimatedConns
+    totalRouted += bestRoutedFraction * estimatedConns
+
+    if (solved) {
+      solvedCount++
+    }
+  }
+
+  if (progressLabel) {
+    process.stdout.write("\r" + " ".repeat(50) + "\r")
+  }
+
+  return {
+    continuousScore: totalRouted / totalConnections,
+    successRate: solvedCount / configs.length,
+    totalRouted,
+    totalConnections,
+  }
+}