amplify-bbopt 0.2.2__tar.gz → 0.2.4__tar.gz

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amplify-bbopt
-Version: 0.2.2
+Version: 0.2.4
 Summary: An Amplify-based library to facilitate black-box optimization
 Author-email: Fixstars Amplify Corporation <y_matsuda@fixstars.com>
 Maintainer-email: Yoshiki Matsuda <y_matsuda@fixstars.com>, Yuki Minamoto <yuki.minamoto@fixstars.com>

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/amplify_bbopt/__version__.py

@@ -3,4 +3,4 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/amplify_bbopt/constraint.py

@@ -158,12 +158,9 @@ class Constraint:
     def penalty_formulation(self) -> str:
         """The Amplify SDK's `penalty_formulation` parameter.
 
-        Set this to "Relaxation" when:
-
-        (1) Imposing an inequality constraint with real variables (when coefficients in the constraint formulation is likely to yield real numbers), AND
-
-        (2) The specified solver (e.g Amplify Annealing Engine) being a QUBO solver that does not support real variables,
-        until the Amplify SDK used internally in Amplify-BBOpt supports the real-to-binary variable conversion. See: https://amplify.fixstars.com/ja/docs/amplify/v1/penalty.html#ineq-penalty
+        Set this to "Relaxation" when you:
+          (1) impose an inequality constraint with real variables (when coefficients in the constraint formulation is likely to yield real numbers), AND
+          (2) the specified solver (e.g Amplify Annealing Engine) is a QUBO solver that does not support real variables, until the Amplify SDK used internally in Amplify-BBOpt supports the real-to-binary variable conversion. See: https://amplify.fixstars.com/ja/docs/amplify/v1/penalty.html#ineq-penalty
         """  # noqa: E501
         return self._penalty_formulation
 
@@ -171,10 +168,9 @@ class Constraint:
     def penalty_formulation(self, value: str) -> None:
         """Set the Amplify SDK's `penalty_formulation` parameter.
 
-        Set this to "Relaxation" when:
-        - Imposing an inequality constraint with real variables (when coefficients in the constraint formulation is likely to yield real numbers), AND
-        - The specified solver (e.g Amplify Annealing Engine) being a QUBO solver that does not support real variables,
-        until the Amplify SDK used internally in Amplify-BBOpt supports the real-to-binary variable conversion. See: https://amplify.fixstars.com/ja/docs/amplify/v1/penalty.html#ineq-penalty
+        Set this to "Relaxation" when you:
+          (1) impose an inequality constraint with real variables (when coefficients in the constraint formulation is likely to yield real numbers), AND
+          (2) the specified solver (e.g Amplify Annealing Engine) is a QUBO solver that does not support real variables, until the Amplify SDK used internally in Amplify-BBOpt supports the real-to-binary variable conversion. See: https://amplify.fixstars.com/ja/docs/amplify/v1/penalty.html#ineq-penalty
 
         Args:
             value (float): A `penalty_formulation`.
@@ -196,9 +192,9 @@ class Constraint:
         elif self.op == LE:
             c = amplify.less_equal(poly, self.right, penalty_formulation=self._penalty_formulation)  # type: ignore
         elif self.op == GE:
-            c = amplify.greater_equal(poly, self.right)  # type: ignore
+            c = amplify.greater_equal(poly, self.right, penalty_formulation=self._penalty_formulation)  # type: ignore
         elif self.op == CL:
-            c = amplify.clamp(poly, self.right)  # type: ignore
+            c = amplify.clamp(poly, self.right, penalty_formulation=self._penalty_formulation)  # type: ignore
         else:
             raise ValueError(f"{self.op} is invalid keyword.")
         c.weight = self._weight
@@ -233,7 +229,7 @@ class Constraint:
         if self.op == GE:
             return left_val >= self.right  # type: ignore
         if self.op == CL:
-            return self.right[0] <= left_val and left_val <= self.right[1]  # type: ignore
+            return self.right[0] <= left_val <= self.right[1]  # type: ignore
         raise ValueError(f"{self.op} is invalid keyword.")
 
     def __str__(self) -> str:

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/amplify_bbopt/data_gen.py

@@ -151,4 +151,3 @@ class DatasetGenerator:
             return data_list_list[0]
 
         return tuple(data_list_list)
-        return tuple(data_list_list)

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/amplify_bbopt/optimizer.py

@@ -493,7 +493,7 @@ class QAOptimizerBase(OptimizerBase, Generic[T, M]):
 
     def _generate_alternative_solution(
         self, solution: StructuredSolution | None, search_count_max: int, find_neighbour: bool = False
-    ) -> StructuredSolution:
+    ) -> StructuredSolution | None:
         """Generate a solution that is close to the original solution. The new solution also meets the user defined constraints when a sufficient search_count_max is given.
 
         Args:
@@ -502,14 +502,14 @@ class QAOptimizerBase(OptimizerBase, Generic[T, M]):
             find_neighbour (bool, optional): True to generate a random value neighbour to the reference value. Defaults to `False`.
 
         Returns:
-            StructuredSolution: The (updated)) solution.
+            StructuredSolution | None: The (updated)) solution. If not found solution (that meet constraints), returns `None` (this happens when the solution is originally `None`).
         """  # noqa: E501
         for _ in range(search_count_max):
             solution_new = self._objective.variables.generate_random_value(self._rng, solution, find_neighbour)
             if self.constraints.is_satisfied(solution_new.to_flat().to_solution_dict()):
                 return solution_new
         logger().warning("No alternative solution was found that meets the constraints. The original solution is used.")
-        assert solution is not None
+        # assert solution is not None
         return solution
 
     def _ensure_uniqueness(
@@ -545,15 +545,24 @@ class QAOptimizerBase(OptimizerBase, Generic[T, M]):
                 # if the same solution appears "frequently", alternative solution is made such that
                 # the new solution is close (in the below two levels) to the original solution.
                 if how_frequent % 2 == 0:
-                    solution = self._generate_alternative_solution(solution, search_count_max, find_neighbour=True)
+                    alternative_solution = self._generate_alternative_solution(
+                        solution, search_count_max, find_neighbour=True
+                    )
+                    assert alternative_solution is not None
+                    solution = alternative_solution
                 else:
-                    solution = self._generate_alternative_solution(solution, search_count_max)
+                    alternative_solution = self._generate_alternative_solution(solution, search_count_max)
+                    assert alternative_solution is not None
+                    solution = alternative_solution
             else:
                 # If the same solution appears not too often, generate an alternative solution randomly.
                 # If the same solution appears too often, SolutionFrequency returns is_frequent=False.
                 # This is because such solution is perhaps the result of optimizer being trapped in a local minimum.
                 # Thus, and alternative solution is generated randomly.
-                solution = self._generate_alternative_solution(None, search_count_max)
+                alternative_solution = self._generate_alternative_solution(None, search_count_max)
+                solution = original_solution.copy() if alternative_solution is None else alternative_solution
+                # "alternative_solution is None" happens when set constraints are too complex and
+                # _generate_alternative_solution could not find alternative solution.
 
         return original_solution, False
 

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/amplify_bbopt/trainer.py

@@ -127,14 +127,14 @@ class TorchFMTrainer(TrainerBase):
 
             # Validation
             with torch.no_grad():
+                loss = 0
                 for x_valid, y_valid in valid_loader:
-                    loss = 0
                     y_pred = model(x_valid)
                     loss += criterion(y_pred, y_valid)
-                    # If the loss is updated, update the parameters
-                    if loss < min_loss:
-                        best_parameters = copy.deepcopy(model.state_dict())
-                        min_loss = loss
+                # If the loss is updated, update the parameters
+                if loss < min_loss:
+                    best_parameters = copy.deepcopy(model.state_dict())
+                    min_loss = loss
             if scheduler is not None:
                 scheduler.step()
 

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/amplify_bbopt/variable.py

@@ -1088,7 +1088,7 @@ class IntegerVariable(VariableBase):
 
         if value < self.bounds[0] or value > self.bounds[1]:
             raise ValueError(f"Given value {value} must be bounded by bounds={self.bounds}.")
-        return value - self.bounds[0]
+        return int(value - self.bounds[0])
 
     def idx_to_value(self, idx: int) -> int:
         """Converts a value index to a value of the variable.

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/amplify_bbopt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amplify-bbopt
-Version: 0.2.2
+Version: 0.2.4
 Summary: An Amplify-based library to facilitate black-box optimization
 Author-email: Fixstars Amplify Corporation <y_matsuda@fixstars.com>
 Maintainer-email: Yoshiki Matsuda <y_matsuda@fixstars.com>, Yuki Minamoto <yuki.minamoto@fixstars.com>

{amplify_bbopt-0.2.2 → amplify_bbopt-0.2.4}/test/test_optimizer.py

@@ -21,10 +21,14 @@ from amplify_bbopt import (
     IntegerVariableList,
     KernelQAOptimizer,
     MultiObjectiveOptimizer,
+    RealVariableList,
     StructuredSolution,
     TorchFMTrainer,
     blackbox,
+    clamp,
     equal_to,
+    greater_equal,
+    less_equal,
     logger,
 )
 
@@ -60,6 +64,14 @@ def objective_func_4(
     return sum(x) + c
 
 
+@blackbox
+def objective_func_4_real(
+    x: Annotated[list[float], RealVariableList(bounds=(0, 9), nbins=5, length=3)],
+    c: Annotated[int, IntegerVariable(bounds=(0, 19))],
+):
+    return sum(x) + c
+
+
 assert logger.handler is not None
 logger.handler.setLevel(logging.ERROR)
 
@@ -112,6 +124,49 @@ def kernel_qa_optimizer_4(require_client=True):
     return KernelQAOptimizer(data, objective_func_4, client, seed=0)
 
 
+@pytest.fixture
+def kernel_qa_optimizer_4_impossible_constraint(require_client=True):
+    client = None
+    if require_client:
+        client = amplify.FixstarsClient()
+        client.parameters.timeout = timedelta(milliseconds=1000)  # 1000 ミリ秒
+        # client.token = ""
+
+    variables = objective_func_4.variables
+    assert isinstance(variables.x, IntegerVariableList)
+    c = equal_to(variables.x, 30)
+    objective_func_4.add_constraint(c)
+
+    data = DatasetGenerator(objective=objective_func_4, meet_constraints=False, seed=0).generate(num_samples=3)
+    assert isinstance(data, DataList)
+    return KernelQAOptimizer(data, objective_func_4, client, seed=0)
+
+
+@pytest.fixture
+def kernel_qa_optimizer_4_real_inequality_constraint(require_client=True):
+    client = None
+    if require_client:
+        client = amplify.FixstarsClient()
+        client.parameters.timeout = timedelta(milliseconds=1000)  # 1000 ミリ秒
+        # client.token = ""
+
+    variables = objective_func_4_real.variables
+    assert isinstance(variables.x, RealVariableList)
+    c0 = less_equal(variables.x[0] + 2.5 * variables.x[1], 30)
+    c1 = greater_equal(variables.x[0] - 2.5 * variables.x[1], 0)
+    c2 = clamp(variables.x[0] - 2.5 * variables.x[1], (0, 30))
+    c0.penalty_formulation = "Relaxation"
+    c1.penalty_formulation = "Relaxation"
+    c2.penalty_formulation = "Relaxation"
+    objective_func_4_real.add_constraint(c0)
+    objective_func_4_real.add_constraint(c1)
+    objective_func_4_real.add_constraint(c2)
+
+    data = DatasetGenerator(objective=objective_func_4_real, meet_constraints=False, seed=0).generate(num_samples=3)
+    assert isinstance(data, DataList)
+    return KernelQAOptimizer(data, objective_func_4_real, client, seed=0)
+
+
 def test_ensure_uniqueness_single_objective(kernel_qa_optimizer_4):
     rng = np.random.default_rng(seed=0)
 
@@ -132,6 +187,19 @@ def test_ensure_uniqueness_single_objective(kernel_qa_optimizer_4):
     print(f"{ave_distance=}")
 
 
+def test_ensure_uniqueness_constraint(kernel_qa_optimizer_4_impossible_constraint):
+    # To test ensure_uniqueness returns a solution even when impossible constraints are set.
+
+    solution = FlatSolution(
+        kernel_qa_optimizer_4_impossible_constraint.objective.variables,
+        kernel_qa_optimizer_4_impossible_constraint.data.x[0],
+    ).to_structured()
+    org_solution = solution.copy()
+    solution, is_modified = kernel_qa_optimizer_4_impossible_constraint._ensure_uniqueness(solution, 10)  # noqa: SLF001
+    assert solution.values == org_solution.values
+    assert not is_modified
+
+
 def test_fmqa_optimizer(fmqa_optimizer):
     poly_array = fmqa_optimizer.objective.variables.poly_array
     custom_obj = poly_array[0] * poly_array[1]
@@ -156,7 +224,6 @@ def test_fmqa_optimizer(fmqa_optimizer):
     fmqa_optimizer._elapsed_time.append(0)  # noqa: SLF001
     fmqa_optimizer._is_de_duplication.append(True)  # noqa: SLF001
     history = fmqa_optimizer.fetch_history()
-    print(history.history_df)
 
     assert len(history.history_df) == 4
     assert history.num_initial_data == 4
@@ -191,6 +258,10 @@ def test_fmqa_optimizer(fmqa_optimizer):
     assert "x" in fmqa_optimizer.best_solution
 
 
+def test_kernel_qa_optimizer_4_real_inequality_constraint(kernel_qa_optimizer_4_real_inequality_constraint):
+    kernel_qa_optimizer_4_real_inequality_constraint.optimize(num_cycles=1)
+
+
 def test_multi_objective_optimizer_dependency_variables_unification(fmqa_optimizer, kernel_qa_optimizer):
     # two objective functions dependent via a common variable x.
     # test to correctly unify the variables.