M2: Harden matrix execution (resume/timeout), add coverage notebooks, and expand M2 tests

.gitignore

@@ -4,4 +4,16 @@ __pycache__/
 external/*
 **/uv.lock
 *.egg-info/
-**/.venv/
+**/.venv/
+.env
+runs/
+runs_test/
+notebooks/01_smoke_runner_with_output.ipynb
+notebooks/01_m1_minimal_api_with_output.ipynb
+/.tmp_runs_run
+/.tmp_runs_validate
+_diag.py
+/_test_diag
+/.tmp_m2_validate
+.pytest_tmp*/
+pytest_tmp*/

LLM4AD/benchmark_tasks/optimization_hybrid_reentrant_shop_scheduling/__init__.py

@@ -114,8 +114,8 @@ def load_data(self, input_string):
              - 'setup_times': list of integers
              - 'processing_times': list of integers
         """
-import os, sys
-sys.path.insert(0, os.path.dirname(__file__))
+        import os, sys
+        sys.path.insert(0, os.path.dirname(__file__))
         import re
         cases = []
         lines = [line.strip() for line in input_string.split('\n') if line.strip() != '']

LLM4AD/benchmark_tasks/optimization_set_covering/__init__.py

@@ -124,8 +124,8 @@ def load_data(self, input_string):
              - "costs": list of column costs (list of int)
              - "row_cover": list of lists; each inner list contains the 1-indexed column numbers covering that row.
         """
-import os, sys
-sys.path.insert(0, os.path.dirname(__file__))
+        import os, sys
+        sys.path.insert(0, os.path.dirname(__file__))
         import re
 
         content = input_string.strip()

LLM4AD/benchmark_tasks/optimization_tsp_gls_2O/get_instance.py

@@ -17,7 +17,7 @@ def generate_instances(self):
         return instance_data
 
 class TSPInstance:
-    def __init__(self, positions: npt.NDArray[np.float_]) -> None:
+    def __init__(self, positions: npt.NDArray[np.float64]) -> None:
         self.positions = positions
         self.n = positions.shape[0]
         self.distmat = distance_matrix(positions, positions) + np.eye(self.n)*1e-5

LLM4AD/benchmark_tasks/optimization_tsp_gls_2O/gls.py

@@ -6,8 +6,8 @@
 import concurrent.futures
 from typing import Tuple
 
-FloatArray = npt.NDArray[np.float_]
-IntArray = npt.NDArray[np.int_]
+FloatArray = npt.NDArray[np.float64]
+IntArray = npt.NDArray[np.int64]
 usecache = True
 
 

LLM4AD/benchmark_tasks/science_discovery_bactgrow/__init__.py

@@ -60,8 +60,7 @@
 template_program = 'import numpy as np\n\ndef equation(b: np.ndarray, s: np.ndarray, temp: np.ndarray, pH: np.ndarray, params: np.ndarray) -> np.ndarray:\n    """ Mathematical function for bacterial growth rate\n    Args:\n        b: A numpy array representing observations of population density of the bacterial species.\n        s: A numpy array representing observations of substrate concentration.\n        temp: A numpy array representing observations of temperature.\n        pH: A numpy array representing observations of pH level.\n        params: Array of numeric constants or parameters to be optimized\n\n    Return:\n        A numpy array representing bacterial growth rate as the result of applying the mathematical function to the inputs.\n    """\n    return params[0] * b + params[1] * s + params[2] * temp + params[3] * pH + params[4]'
 task_description = '("Find the mathematical function skeleton that represents E. Coli bacterial growth rate, "'
 
-from bactgrow import train
-# from llm4ad.task.science_discovery.bactgrow import train  # Converted from LLM4AD import
+from . import train
 
 __all__ = ['BGEvaluation']
 

LLM4AD/benchmark_tasks/science_discovery_feynman_srsd/feynman_equations.py

@@ -3,9 +3,9 @@
 import numpy as np
 import sympy
 
-from .base import KnownEquation
+from base import KnownEquation
 # from .registry import register_eq_class
-from .sampling import DefaultSampling, IntegerSampling, SimpleSampling
+from sampling import DefaultSampling, IntegerSampling, SimpleSampling
 
 FEYNMAN_EQUATION_CLASS_List = []  # OrderedDict()
 GRAVITATIONAL_CONSTANT = 6.67430e-11
@@ -3612,4 +3612,4 @@ def __init__(self, sampling_objs=None):
         self.sympy_eq = 1 / (4 * sympy.pi) * FINE_STRUCTURE_CONSTANT ** 2 * PLANCK_CONSTANT ** 2 / (ELECTRON_MASS ** 2 * SPEED_OF_LIGHT ** 2) * (x[0] / x[1]) ** 2 * (x[0] / x[1] + x[1] / x[0] - sympy.sin(x[2]) ** 2)
 
     def eq_func(self, x):
-        return 1 / (4 * np.pi) * FINE_STRUCTURE_CONSTANT ** 2 * PLANCK_CONSTANT ** 2 / (ELECTRON_MASS ** 2 * SPEED_OF_LIGHT ** 2) * (x[0] / x[1]) ** 2 * (x[0] / x[1] + x[1] / x[0] - np.sin(x[2]) ** 2)
+        return 1 / (4 * np.pi) * FINE_STRUCTURE_CONSTANT ** 2 * PLANCK_CONSTANT ** 2 / (ELECTRON_MASS ** 2 * SPEED_OF_LIGHT ** 2) * (x[0] / x[1]) ** 2 * (x[0] / x[1] + x[1] / x[0] - np.sin(x[2]) ** 2)

LLM4AD/benchmark_tasks/science_discovery_ode_1d/__init__.py

@@ -57,8 +57,7 @@
 template_program = 'import numpy as np\n\ndef equation(x: float, params: np.ndarray) -> float:\n    """ A ODE mathematical function    \n    Args:\n        x: the initial float value of the ode formula\n        params: a 1-d Array of numeric constants or parameters to be optimized\n\n    Return:\n        A numpy array representing the result of applying the mathematical function to the inputs.\n    """\n    y = params[0] * x + params[2]\n    return y'
 task_description = '("Find the ODE mathematical function skeleton, given data on initial x. The function should be differentiable, continuous."'
 
-from ode_1d import strogatz_extended, strogatz_equations
-# from llm4ad.task.science_discovery.ode_1d import strogatz_extended, strogatz_equations  # Converted from LLM4AD import
+from . import strogatz_extended, strogatz_equations
 
 __all__ = ['ODEEvaluation']
 

LLM4AD/benchmark_tasks/science_discovery_oscillator1/__init__.py

@@ -56,8 +56,7 @@
 template_program = 'import numpy as np\n\ndef equation(x: np.ndarray, v: np.ndarray, params: np.ndarray) -> np.ndarray:\n    """ Mathematical function for acceleration in a damped nonlinear oscillator\n    Args:\n        x: A numpy array representing observations of current position.\n        v: A numpy array representing observations of velocity.\n        params: Array of numeric constants or parameters to be optimized\n\n    Return:\n        A numpy array representing acceleration as the result of applying the mathematical function to the inputs.\n    """\n    dv = params[0] * x  +  params[1] * v +  + params[3]\n    return dv'
 task_description = '("Find the mathematical function skeleton that represents acceleration in a damped nonlinear "'
 
-from oscillator1 import train
-# from llm4ad.task.science_discovery.oscillator1 import train  # Converted from LLM4AD import
+from . import train
 
 __all__ = ['OscillatorEvaluation1']
 

LLM4AD/benchmark_tasks/science_discovery_oscillator2/__init__.py

@@ -58,8 +58,7 @@
 template_program = 'import numpy as np\n\ndef equation(t: np.ndarray, x: np.ndarray, v: np.ndarray, params: np.ndarray) -> np.ndarray:\n    """ Mathematical function for acceleration in a damped nonlinear oscillator\n    Args:\n        t: A numpy array representing time.\n        x: A numpy array representing observations of current position.\n        v: A numpy array representing observations of velocity.\n        params: Array of numeric constants or parameters to be optimized\n\n    Return:\n        A numpy array representing acceleration as the result of applying the mathematical function to the inputs.\n    """\n    dv = params[0] * t + params[1] * x  +  params[2] * v +  + params[3]\n    return dv'
 task_description = '("Find the mathematical function skeleton that represents acceleration in a damped nonlinear "'
 
-from oscillator2 import train
-# from llm4ad.task.science_discovery.oscillator2 import train  # Converted from LLM4AD import
+from . import train
 
 __all__ = ['OscillatorEvaluation2']
 

LLM4AD/benchmark_tasks/science_discovery_stresstrain/__init__.py

@@ -57,8 +57,7 @@
 template_program = 'import numpy as np\n\ndef equation(strain: np.ndarray, temp: np.ndarray, params: np.ndarray) -> np.ndarray:\n    """ Mathematical function for stress in Aluminium rod\n    Args:\n        strain: A numpy array representing observations of strain.\n        temp: A numpy array representing observations of temperature.\n        params: Array of numeric constants or parameters to be optimized\n\n    Return:\n        A numpy array representing stress as the result of applying the mathematical function to the inputs.\n    """\n    return params[0] * strain  +  params[1] * temp'
 task_description = '("Find the mathematical function skeleton that represents stress, given data on strain and "'
 
-from stresstrain import train
-# from llm4ad.task.science_discovery.stresstrain import train  # Converted from LLM4AD import
+from . import train
 
 __all__ = ['SSEvaluation']