WIP

Author: 0hmX

scripts/make-data-related-to-linear-regression-for-better-pf-for-port-point-calculation.ts

@@ -5,32 +5,49 @@ import { getIntraNodeCrossings } from "lib/utils/getIntraNodeCrossings"
 import { HighDensitySolver } from "lib/solvers/HighDensitySolver/HighDensitySolver"
 
 const settings = [
-  { width: 1, height: 1, z: 1 },
-  { width: 0.1, height: 0.5, z: 1 },
-  { width: 0.5, height: 0.1, z: 1 },
-  { width: 1, height: 1, z: 1 },
-  { width: 2.9, height: 1.9, z: 1 },
+  { width: 1, height: 2.83, z: 1 },
+  { width: 2.83, height: 1, z: 1 },
+  { width: 81.574, height: 50.87, z: 1 },
+  { width: 30.41, height: 68.33, z: 1 },
+  { width: 10.86, height: 29.44, z: 1 },
+  { width: 5.43, height: 16.31, z: 1 },
+  { width: 0.839, height: 0.206, z: 1 },
+  { width: 3.19, height: 1.59, z: 1 },
 ]
 
 const connectionVariants = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 const viaSizesVariants = [0.1, 0.2, 0.3, 0.4, 0.5]
 const traceWidthsVariants = [0.05, 0.1, 0.15, 0.2, 0.25]
 
-type Features = {
-  top_edge_ports_normalized_to_width: number
-  right_edge_ports_normalized_to_height: number
-  bottom_edge_ports_normalized_to_width: number
-  left_edge_ports_normalized_to_height: number
-  same_layer_crossings_normalized_to_if_all_where_layercrossing: number
-  layer_transitions_normalized_to_if_all_connections_where_transition: number
-  single_via_area_normalized_to_area: number
-  two_via_area_normalized_to_area: number
-  board_aspect_ratio_not_normalized: number
-  total_trace_distance_normalized_to_diagonal: number
-  same_net_crossings_normalized_to_segments: number
+const FEATURE_SCHEMA = {
+  top_edge_ports_normalized_to_width: { useForGeometric: true },
+  right_edge_ports_normalized_to_height: { useForGeometric: true },
+  bottom_edge_ports_normalized_to_width: { useForGeometric: true },
+  left_edge_ports_normalized_to_height: { useForGeometric: true },
+  same_layer_crossings_normalized_to_if_all_where_layercrossing: {
+    useForGeometric: false,
+  },
+  layer_transitions_normalized_to_if_all_connections_where_transition: {
+    useForGeometric: false,
+  },
+  single_via_area_normalized_to_area: { useForGeometric: true },
+  two_via_area_normalized_to_area: { useForGeometric: true },
+  board_aspect_ratio_not_normalized: { useForGeometric: true },
+  total_trace_distance_normalized_to_diagonal: { useForGeometric: true },
+  same_net_crossings_normalized_to_segments: { useForGeometric: false },
+} as const
+
+type FeatureKey = keyof typeof FEATURE_SCHEMA
+type Features = Record<FeatureKey, number> & {
   did_hight_density_solver_find_solution?: boolean
 }
 
+type GeometricFeatureKey = {
+  [K in FeatureKey]: (typeof FEATURE_SCHEMA)[K]["useForGeometric"] extends true
+    ? K
+    : never
+}[FeatureKey]
+
 const computeFeaturesForMl = (params: {
   portPoints: NodeWithPortPoints["portPoints"]
   node: CapacityMeshNode
@@ -151,16 +168,7 @@ type Candidate = {
   traceWidth: number
 }
 
-type GeometricFeatures = {
-  top_edge_ports_normalized_to_width: number
-  right_edge_ports_normalized_to_height: number
-  bottom_edge_ports_normalized_to_width: number
-  left_edge_ports_normalized_to_height: number
-  single_via_occupancy_normalized_to_area: number
-  two_via_occupancy_normalized_to_area: number
-  board_aspect_ratio_normalized_to_geometry: number
-  port_distance_normalized_to_diagonal: number
-}
+type GeometricFeatures = Pick<Features, GeometricFeatureKey>
 
 const getGeometricFeatures = (candidate: Candidate): GeometricFeatures => {
   const { node, nodeWithPortPoints, viaSize } = candidate
@@ -201,10 +209,10 @@ const getGeometricFeatures = (candidate: Candidate): GeometricFeatures => {
     right_edge_ports_normalized_to_height: safeDiv(rightPortCount, node.height),
     bottom_edge_ports_normalized_to_width: safeDiv(bottomPortCount, node.width),
     left_edge_ports_normalized_to_height: safeDiv(leftPortCount, node.height),
-    single_via_occupancy_normalized_to_area: safeDiv(viaArea, area),
-    two_via_occupancy_normalized_to_area: safeDiv(viaArea * 2, area),
-    board_aspect_ratio_normalized_to_geometry: safeDiv(node.width, node.height),
-    port_distance_normalized_to_diagonal: safeDiv(
+    single_via_area_normalized_to_area: safeDiv(viaArea, area),
+    two_via_area_normalized_to_area: safeDiv(viaArea * 2, area),
+    board_aspect_ratio_not_normalized: safeDiv(node.width, node.height),
+    total_trace_distance_normalized_to_diagonal: safeDiv(
       totalTraceDistance,
       numNet * diagonal,
     ),
@@ -217,10 +225,10 @@ const featuresToVector = (features: GeometricFeatures): number[] => {
     features.right_edge_ports_normalized_to_height,
     features.bottom_edge_ports_normalized_to_width,
     features.left_edge_ports_normalized_to_height,
-    features.single_via_occupancy_normalized_to_area,
-    features.two_via_occupancy_normalized_to_area,
-    features.board_aspect_ratio_normalized_to_geometry,
-    features.port_distance_normalized_to_diagonal,
+    features.single_via_area_normalized_to_area,
+    features.two_via_area_normalized_to_area,
+    features.board_aspect_ratio_not_normalized,
+    features.total_trace_distance_normalized_to_diagonal,
   ]
 }
 
@@ -361,6 +369,19 @@ const isInformationSaturationReached = (
   return stdDev < 0.01
 }
 
+const saveDatasetToJson = async (
+  dataset: Array<Features & { cost: number }>,
+  filename: string,
+) => {
+  const fs = await import("node:fs/promises")
+  const path = await import("node:path")
+
+  const outputPath = path.join(process.cwd(), filename)
+  const jsonContent = JSON.stringify(dataset, null, 2)
+
+  await fs.writeFile(outputPath, jsonContent, "utf-8")
+}
+
 async function run() {
   const MAX_COMPUTE = 5000
   const SAMPLE_SIZE = 100
@@ -374,6 +395,9 @@ async function run() {
   console.log(`Memory limit check enabled, batch size: ${BATCH_SIZE}`)
 
   let iterationCount = 0
+  let solvedCount = 0
+  let failedCount = 0
+  const TARGET_PER_CLASS = MAX_COMPUTE / 2
 
   while (dataset.length < MAX_COMPUTE) {
     iterationCount++
@@ -439,12 +463,23 @@ async function run() {
 
     hdSolver.solve()
 
-    dataset.push({
-      ...finalFeatures,
-      cost,
-      did_hight_density_solver_find_solution: hdSolver.solved,
-    })
-    processedGeometricFeatures.push(featuresToVector(bestGeo))
+    if (hdSolver.solved && solvedCount < TARGET_PER_CLASS) {
+      solvedCount++
+      dataset.push({
+        ...finalFeatures,
+        cost,
+        did_hight_density_solver_find_solution: hdSolver.solved,
+      })
+      processedGeometricFeatures.push(featuresToVector(bestGeo))
+    } else if (hdSolver.solved && failedCount < TARGET_PER_CLASS) {
+      failedCount++
+      dataset.push({
+        ...finalFeatures,
+        cost,
+        did_hight_density_solver_find_solution: hdSolver.solved,
+      })
+      processedGeometricFeatures.push(featuresToVector(bestGeo))
+    }
 
     if (dataset.length % 10 === 0) {
       console.log(
@@ -473,17 +508,4 @@ async function run() {
   return dataset
 }
 
-const saveDatasetToJson = async (
-  dataset: Array<Features & { cost: number }>,
-  filename: string,
-) => {
-  const fs = await import("node:fs/promises")
-  const path = await import("node:path")
-
-  const outputPath = path.join(process.cwd(), filename)
-  const jsonContent = JSON.stringify(dataset, null, 2)
-
-  await fs.writeFile(outputPath, jsonContent, "utf-8")
-}
-
 run()