eqc-models 0.9.9__py3-none-any.whl → 0.10.1__py3-none-any.whl

eqc_models-0.10.1.data/platlib/compile_extensions.py

@@ -0,0 +1,67 @@
+import os
+import sys
+from setuptools import Extension
+from setuptools.command.build_py import build_py as _build_py
+import numpy
+
+# # Set cvqboost compile args
+# if sys.platform == "darwin":
+#     openmp_prefix = os.environ.get(
+#         "LIBOMP_PREFIX", "/opt/homebrew/opt/libomp"
+#     )
+#     openmp_include = os.path.join(openmp_prefix, "include")
+#     openmp_lib = os.path.join(openmp_prefix, "lib", "libomp.a")
+#     extra_compile_args_cvq = [
+#         "-Xpreprocessor",
+#         "-fopenmp",
+#         "-O3",
+#         "-ffast-math",
+#         "-march=native",
+#     ]
+#     extra_link_args_cvq = [openmp_lib, "-O3", "-march=native"]
+# elif sys.platform.startswith("linux"):
+#     extra_compile_args_cvq = [
+#         "-static-libgcc",
+#         "-fopenmp",
+#         "-O3",
+#         "-ffast-math",
+#     ]
+#     extra_link_args_cvq = [
+#         "-static-libgcc",
+#         "-static-libstdc++",
+#         "-fopenmp",
+#         "-O3",
+#     ]
+# elif sys.platform == "win32":
+#     extra_compile_args_cvq = ["/openmp"]
+#     extra_link_args_cvq = []
+
+# Modules to be compiled and include_dirs when necessary
+extensions = [
+    Extension(
+        "eqc_models.base.polyeval",
+        ["eqc_models/base/polyeval.pyx"],
+        include_dirs=[numpy.get_include()],
+        extra_compile_args=["-O3", "-ffast-math"],
+    ),
+    # Extension(
+    #     "eqc_models.ml.cvqboost_hamiltonian",
+    #     ["eqc_models/ml/cvqboost_hamiltonian.pyx"],
+    #     include_dirs=[numpy.get_include()],
+    #     extra_compile_args=extra_compile_args_cvq,
+    #     extra_link_args=extra_link_args_cvq,
+    # ),
+]
+
+
+class build_py(_build_py):
+    def run(self):
+        self.run_command("build_ext")
+        return super().run()
+
+    def initialize_options(self):
+        super().initialize_options()
+        if self.distribution.ext_modules == None:
+            self.distribution.ext_modules = []
+
+        self.distribution.ext_modules.extend(extensions)

{eqc_models-0.9.9.data → eqc_models-0.10.1.data}/platlib/eqc_models/algorithms/penaltymultiplier.py

@@ -33,6 +33,14 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     penalties : List
         The values for penalties found at each algorithm iteration. A penalty of 0
         indicates algorithm termination.
+    penalty_threshold : float
+        This value is the cutoff for penalty values that are threated as 0. Default
+        is 1e-6. 
+    progress_threshold : float
+        This value is the cutoff for checking for progress on reducing the penalty
+        value. The current penalty is compared to the average of the previous two
+        and if the absolute difference is less than this value, then the algorithm
+        stops, reporting progress has not been made. The default value is 1e-4.
     dynamic_range : List
         The values for the dynamic range of the unconstrained problem formulation,
         which is useful for identifying difficulty in representation of the problem
@@ -50,7 +58,7 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     This example uses the quadratic assignment problem and the known multiplier to test 
     the implementation of the algorithm.
 
-    >>> from eqc_models.solvers.qciclient import Dirac3CloudSolver
+    >>> from eqc_models.solvers.qciclient import Dirac3IntegerCloudSolver
     >>> from eqc_models.assignment.qap import QAPModel
     >>> A = np.array([[0, 5, 8, 0, 1],
     ...               [0, 0, 0, 10, 15],
@@ -68,10 +76,10 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     ...               [7, 5, 8, 5, 7],
     ...               [1, 9, 2, 9, 2.]])
     >>> model = QAPModel(A, B, C)
-    >>> solver = Dirac3CloudSolver() # must be configured with environment variables
+    >>> solver = Dirac3IntegerCloudSolver() # must be configured with environment variables
     >>> algo = PenaltyMultiplierAlgorithm(model, solver)
     >>> algo.upper_bound = 330.64
-    >>> algo.run(relaxation_schedule=2, mean_photon_number=0.15, normalized_loss_rate=4, num_samples=5) # doctest: +ELLIPSIS
+    >>> algo.run(relaxation_schedule=2, num_samples=5) # doctest: +ELLIPSIS
     2... RUNNING... COMPLETED...
     >>> algo.alphas[-1] # doctest: +SKIP
     106.25
@@ -80,7 +88,8 @@ class PenaltyMultiplierAlgorithm(Algorithm):
  
     """
 
-    def __init__(self, model : ConstraintModel, solver : ModelSolver):
+    def __init__(self, model : ConstraintModel, solver : ModelSolver, penalty_threshold:float=1e-6,
+                 progress_threshold : float = 1e-4):
         self.model = model
         self.solver = solver
         # ub = np.max(model.quad_objective)
@@ -95,6 +104,8 @@ class PenaltyMultiplierAlgorithm(Algorithm):
         self.alphas = None
         self.dynamic_range = None
         self.responses = None
+        self.penalty_threshold = penalty_threshold
+        self.progress_threshold = progress_threshold
 
     @property
     def upper_bound(self) -> float:
@@ -141,7 +152,7 @@ class PenaltyMultiplierAlgorithm(Algorithm):
         else:
             penalty = None
             
-        while penalty is None or penalty > 1e-6:
+        while penalty is None or penalty > self.penalty_threshold:
             log.info("NEW RUN")
             log.info("SETTING MULTIPLIER %f", alpha)
             model.penalty_multiplier = float(alpha)
@@ -162,8 +173,10 @@ class PenaltyMultiplierAlgorithm(Algorithm):
             energies.append(results["energies"][0])
             log.info("NEW SOLUTION OBJECTIVE %f LESS OFFSET %f ENERGY %f PENALTY %f", 
                      obj_val, less_offset, energies[-1], penalty)
-            if obj_val < ub:
+            if penalty < self.penalty_threshold:
+                pass
+            elif obj_val < ub:
                 alpha += (ub - obj_val) / penalty
-            if abs(sum(penalties[-2:])/2-penalty) < 1e-4:
+            if penalty > self.penalty_threshold and abs(sum(penalties[-2:])/2-penalty) < self.progress_threshold:
                 log.warn("SUFFICIENT PROGRESS NOT MADE FOR THREE ITERATIONS, QUITTING")
                 break