Merge branch 'main' into solve-while-model

Author: Dimosts

pycona/active_algorithms/genacq.py

@@ -68,6 +68,7 @@ def learn(self, instance: ProblemInstance, oracle: Oracle = UserOracle(), verbos
                 if self.env.verbose >= 1:
                     print(f"\nLearned {self.env.metrics.cl} constraints in "
                           f"{self.env.metrics.total_queries} queries.")
+                self.env.instance.bias = []
                 return self.env.instance
 
             self.env.metrics.increase_generation_time(gen_end - gen_start)
@@ -108,7 +109,7 @@ def generalize(self, r, c):
         for var in scope_vars:
             var_types = []
             for type_group in self._types:
-                if var.name in type_group:
+                if var in type_group:
                     var_types.append(type_group)
             type_sequences.append(var_types)
 
@@ -139,6 +140,7 @@ def generalize(self, r, c):
         all_type_sequences.sort(key=lambda seq: len(set().union(*seq)))
 
         while len(all_type_sequences) > 0 and gq_counter < self._qg_max:
+
             Y = all_type_sequences.pop(0)    
 
             # Instead of getting constraints from bias, generate them for this type sequence

pycona/active_algorithms/growacq.py

@@ -51,14 +51,23 @@ def learn(self, instance: ProblemInstance, oracle: Oracle = UserOracle(), verbos
         self.inner_algorithm.env = copy.copy(self.env)
 
         Y = []
+        init_bias = list(self.env.instance.bias)
+        init_bias_provided = len(init_bias) > 0
 
         n_vars = len(X)
         for x in X:
-            # we 'grow' the inner bias by adding one extra variable at a time
+            # we 'grow' the considered part of the problem by adding one extra variable at a time
             Y.append(x)
-            # add the constraints involving x and other added variables
-            if len(self.env.instance.bias) == 0:
+            # Add candidate constraints for the new frontier.
+            # - If an initial bias is provided, only reveal newly visible constraints
+            # - Otherwise, generate constraints incrementally from the language
+            if init_bias_provided:
+                visible_now = set(get_con_subset(init_bias, Y))
+                self.env.instance.bias = list(visible_now)
+                init_bias = set(init_bias) - visible_now
+            else:
                 self.env.instance.construct_bias_for_vars(x, Y)
+                
             if verbose >= 3:
                 print(f"Added variable {x} in GrowAcq")
                 print("size of B in growacq: ", len(self.env.instance.bias))

pycona/benchmarks/__init__.py

@@ -6,4 +6,6 @@
 from .nurse_rostering import construct_nurse_rostering
 from .zebra import construct_zebra_problem
 from .nqueens import construct_nqueens_problem
-from .golomb import construct_golomb
+from .golomb import construct_golomb
+from .latin_squares import construct_latin_squares
+from .greater_than_sudoku import construct_gtsudoku

pycona/benchmarks/greater_than_sudoku.py

@@ -0,0 +1,69 @@
+import cpmpy as cp
+from cpmpy.transformations.normalize import toplevel_list
+from ..answering_queries.constraint_oracle import ConstraintOracle
+from ..problem_instance import ProblemInstance, absvar
+
+
+def construct_gtsudoku(block_size_row=2, block_size_col=2, grid_size=4):
+    """
+    :return: a ProblemInstance object, along with a constraint-based oracle
+    """
+
+    # Create a dictionary with the parameters
+    parameters = {"block_size_row": block_size_row, "block_size_col": block_size_col, "grid_size": grid_size}
+
+    # Variables
+    grid = cp.intvar(1, grid_size, shape=(grid_size, grid_size), name="grid")
+
+    model = cp.Model()
+
+    # Constraints on rows and columns
+    for row in grid:
+        model += cp.AllDifferent(row).decompose()
+
+    for col in grid.T:  # numpy's Transpose
+        model += cp.AllDifferent(col).decompose()
+
+    # Constraints on blocks
+    for i in range(0, grid_size, block_size_row):
+        for j in range(0, grid_size, block_size_col):
+            model += cp.AllDifferent(grid[i:i + block_size_row, j:j + block_size_col]).decompose()  # python's indexing
+
+    true_horizontal_gt = [
+        (0, 0, 0, 1),  
+        (1, 1, 1, 2),  
+        (2, 2, 2, 3),  
+        (3, 3, 3, 4),  
+        (4, 4, 4, 5),  
+    ]
+    
+    for r1, c1, r2, c2 in true_horizontal_gt:
+        if r2 < grid_size and c2 < grid_size:
+            model += (grid[r1, c1] > grid[r2, c2])
+            
+    true_vertical_gt = [
+        (0, 2, 1, 2),  
+        (1, 3, 2, 3),  
+        (2, 4, 3, 4),  
+        (3, 5, 4, 5),  
+        (4, 6, 5, 6),  
+    ]
+    
+    for r1, c1, r2, c2 in true_vertical_gt:
+        if r1 < grid_size and r2 < grid_size and c1 < grid_size and c2 < grid_size:
+            model += (grid[r1, c1] > grid[r2, c2])
+
+
+    C_T = list(set(toplevel_list(model.constraints)))
+
+    # Create the language:
+    AV = absvar(2)  # create abstract vars - as many as maximum arity
+
+    # create abstract relations using the abstract vars
+    lang = [AV[0] == AV[1], AV[0] != AV[1], AV[0] < AV[1], AV[0] > AV[1], AV[0] >= AV[1], AV[0] <= AV[1]]
+
+    instance = ProblemInstance(variables=grid, params=parameters, language=lang, name=f"sudoku_{block_size_row}_{block_size_col}_{grid_size}")
+
+    oracle = ConstraintOracle(C_T)
+
+    return instance, oracle

pycona/benchmarks/latin_squares.py

@@ -0,0 +1,39 @@
+import cpmpy as cp
+from cpmpy.transformations.normalize import toplevel_list
+from ..answering_queries.constraint_oracle import ConstraintOracle
+from ..problem_instance import ProblemInstance, absvar
+
+
+def construct_latin_squares(grid_size=4):
+    """
+    :return: a ProblemInstance object, along with a constraint-based oracle
+    """
+
+    # Create a dictionary with the parameters
+    parameters = {"grid_size": grid_size}
+
+    # Variables
+    grid = cp.intvar(1, grid_size, shape=(grid_size, grid_size), name="grid")
+
+    model = cp.Model()
+
+    # Constraints on rows and columns
+    for row in grid:
+        model += cp.AllDifferent(row).decompose()
+
+    for col in grid.T:  # numpy's Transpose
+        model += cp.AllDifferent(col).decompose()
+
+    C_T = list(set(toplevel_list(model.constraints)))
+
+    # Create the language:
+    AV = absvar(2)  # create abstract vars - as many as maximum arity
+
+    # create abstract relations using the abstract vars
+    lang = [AV[0] == AV[1], AV[0] != AV[1], AV[0] < AV[1], AV[0] > AV[1], AV[0] >= AV[1], AV[0] <= AV[1]]
+
+    instance = ProblemInstance(variables=grid, params=parameters, language=lang, name=f"latin_squares_{grid_size}")
+
+    oracle = ConstraintOracle(C_T)
+
+    return instance, oracle

pycona/benchmarks/sudoku.py

@@ -37,7 +37,7 @@ def construct_sudoku(block_size_row=2, block_size_col=2, grid_size=4):
     # create abstract relations using the abstract vars
     lang = [AV[0] == AV[1], AV[0] != AV[1], AV[0] < AV[1], AV[0] > AV[1], AV[0] >= AV[1], AV[0] <= AV[1]]
 
-    instance = ProblemInstance(variables=grid, params=parameters, language=lang, name="sudoku")
+    instance = ProblemInstance(variables=grid, params=parameters, language=lang, name=f"sudoku_{block_size_row}_{block_size_col}_{grid_size}")
 
     oracle = ConstraintOracle(C_T)
 

pycona/ca_environment/active_ca.py

@@ -50,6 +50,10 @@ def init_state(self, instance, oracle, verbose, metrics=None):
         self.find_scope.ca = self
         self.findc.ca = self
 
+        # Reset optional query-generator internal state between independent runs
+        if hasattr(self.qgen, "reset_partial") and callable(self.qgen.reset_partial):
+            self.qgen.reset_partial()
+
     def run_query_generation(self, Y=None):
         """ Run the query generation process. """
         Y = self.qgen.generate(Y)

pycona/find_scope/findscope.py

@@ -26,7 +26,7 @@ def run(self, Y):
         :return: The scope of the partial example.
         """
         assert self.ca is not None
-        scope = self._find_scope(set(), Y, do_ask=False)
+        scope = self._find_scope(set(), list(Y), do_ask=False)
         return scope
 
     def _find_scope(self, R, Y, do_ask):

pycona/find_scope/findscope2.py

@@ -78,7 +78,7 @@ def _find_scope(self, R, Y):
 
         # Create Y1, Y2 -------------------------
         proba = self.ca.bias_proba if hasattr(self.ca, 'bias_proba') else []
-        Y1, Y2 = self.split_func(Y=Y, R=R, kappaB=kappaBRY, P_c=proba)
+        Y1, Y2 = self.split_func(Y=Y, R=R, kappaB=kappaBRY, P_c=proba, time_limit=self.time_limit)
 
         S1 = set()
         S2 = set()

pycona/find_scope/findscope_obj.py

@@ -31,13 +31,16 @@ def split_proba(Y, R, kappaB, P_c, **kwargs):
     if len(kappaB) > 10000:
         return split_half(Y)
 
+    time_limit = kwargs.get('time_limit', 1)
+
     hashY = [hash(y) for y in Y]
     hashR = [hash(r) for r in R]
 
     x = cp.boolvar(shape=(len(Y),))
 
     model = cp.Model()
 
+
     Y1_size = sum(x)
 
     model += Y1_size <= (len(Y) + 1) // 2
@@ -65,7 +68,7 @@ def split_proba(Y, R, kappaB, P_c, **kwargs):
 
     s.maximize(objective)
 
-    flag = s.solve(time_limit=1)
+    flag = s.solve(time_limit=time_limit)
 
     if not flag:
         restore_scope_values(x, values)