eqc-models 0.9.8__py3-none-any.whl → 0.10.0__py3-none-any.whl

eqc_models-0.10.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.c

@@ -0,0 +1,68 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <omp.h>
+#include "cvqboost_hamiltonian_c_func.h"
+
+void get_hamiltonian_c(
+    float **J,
+    float *C,
+    float **h_vals,
+    float *y,        
+    float lambda_coef,    
+    int n_records,
+    int n_classifiers
+) {
+    float tmp_i, tmp_j;
+
+    //    omp_set_num_threads(8);
+
+    /*
+    #pragma omp parallel
+    {
+        #pragma omp single
+        printf("Number of threads: %d\n", omp_get_num_threads());
+    }
+    */
+    
+    double start = omp_get_wtime();
+    // Compute J matrix
+    //#pragma omp parallel for collapse(2) //schedule(static,10)
+    for (int i = 0; i < n_classifiers; i++) {
+        for (int j = 0; j < n_classifiers; j++) {
+            J[i][j] = 0.0f;
+
+            // Parallelized innermost loop
+            #pragma omp parallel for reduction(+:J[i][j]) schedule(dynamic, 10000)
+            for (int k = 0; k < n_records; k++) {
+                tmp_i = h_vals[i][k];
+                tmp_j = h_vals[j][k];
+                J[i][j] += tmp_i * tmp_j;
+            }
+        }
+    }
+    double end = omp_get_wtime();
+    printf("Time J loop: %f seconds\n", end - start);
+    
+    // Compute C vector
+    start = omp_get_wtime();    
+    //#pragma omp parallel for schedule(static,10) 
+    for (int i = 0; i < n_classifiers; i++) {
+        C[i] = 0.0f;
+
+        // Parallelized innermost loop
+        #pragma omp parallel for reduction(+:C[i]) schedule(dynamic, 10000)
+        for (int m = 0; m < n_records; m++) {
+            tmp_i = -2.0f * y[m] * h_vals[i][m];
+            C[i] += tmp_i;
+        }
+    }
+    end = omp_get_wtime();
+    printf("Time C loop: %f seconds\n", end - start);
+
+    // Add lambda_coef to the diagonal of J
+    //#pragma omp parallel for schedule(static)
+    for (int i = 0; i < n_classifiers; i++) {
+        J[i][i] += lambda_coef;
+    }
+}

eqc_models-0.10.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.h

@@ -0,0 +1,14 @@
+#ifndef CVQBOOST_HAMILTONIAN_C_FUNC_H
+#define CVQBOOST_HAMILTONIAN_C_FUNC_H
+
+void get_hamiltonian_c(
+    float **J,
+    float *C,
+    float **h_vals,
+    float *y,
+    float lambda_coef,
+    int n_records,
+    int n_classifiers
+);
+
+#endif // CVQBOOST_HAMILTONIAN_C_FUNC_H

eqc_models-0.10.0.data/platlib/eqc_models/quadraticmodel.py

@@ -0,0 +1,131 @@
+from typing import Tuple
+import numpy as np
+from .base import EqcModel
+
+class QuadraticMixIn:
+    C = None
+    J = None
+
+    def encode(self, levels:int=200, norm_value:float=None, dtype=np.float32) -> np.ndarray:
+        """ 
+        Encode Hamiltonian into the domain of the device 
+
+        The encoding method can be tuned using levels or norm_value. The parameter 
+        levels and the member self.domains are used to generate a vector t such that
+        $$
+        x = ts
+        $$
+        thus,
+        $$
+        h^Tx + x^TJx = h^T(ts) + (ts)^TJ(ts) = (th)^Ts + s^T(t\\cross tJ)s
+        $$
+        
+        """
+
+        n = max(self.domains.shape)
+        J = self.J
+        C = self.C
+        if norm_value is None:
+            max_level = levels - 1
+            multipliers = (self.domains) / max_level
+            J = np.array(np.outer(multipliers, multipliers) * J)
+            # h = np.multiply(h[:,0], multipliers)
+            C *= multipliers
+            C = C.reshape((n, 1))
+        else:
+            # normalize the operator
+            max_val_J = np.max(np.abs(J))
+            max_val_C = np.max(np.abs(C))
+            if max_val_J > max_val_C:
+                max_val = max_val_J
+            else:
+                max_val = max_val_C
+            C /= max_val
+            C *= norm_value
+            J /= max_val
+            J *= norm_value
+        # make J symmetric
+        J += J.T
+        J /= 2
+        # return operator in hJ format
+        H = np.hstack([C, J]).astype(dtype)
+
+        if self.machine_slacks > 0:
+            machine_slacks = self.machine_slacks
+            n = H.shape[0]
+            Hslack = np.zeros((n+machine_slacks, n+machine_slacks+1), dtype=dtype)
+            Hslack[:n, :n+1] = H
+            H = Hslack
+    
+        return np.array(H)
+        
+    @property
+    def sparse(self) -> Tuple[np.ndarray, np.ndarray]:
+        """ Put the linear and quadratic terms in a sparse format 
+        
+        :returns: coefficients : List, indices : List
+        """
+        C, J = self.H
+        n = self.n
+        indices = []
+        coefficients = []
+        # build a key (ordered tuple of indices) of length 2 for each element
+        for i in range(n):
+            if C[i,0] != 0:
+                key = (0, i+1)
+                indices.append(key)
+                coefficients.append(C[i,0])
+        # make J upper triangular
+        J = np.triu(J) + np.tril(J, -1).T
+        for i in range(n):
+            for j in range(i, n):
+                val = J[i, j]
+                if val != 0:
+                    key = (i+1, j+1)
+                    indices.append(key)
+                    coefficients.append(val)
+        return np.array(coefficients, dtype=np.float32), np.array(indices, dtype=np.int32)
+    
+    def evaluate(self, solution: np.ndarray, decode:bool=False, levels:int=200) -> float:
+        """ 
+        Evaluate the solution using the original operator. The decode
+        and levels parameters control the decoding of the solution. Without
+        specifying decode, the evaluation of the operator is done with the
+        solution provided.
+         
+        """
+        H = self.H
+        h, J = H[:, 0], H[:, 1:]
+        if decode:
+            sol = self.decode(solution)
+        else:
+            sol = solution
+        return np.squeeze(sol.T@J@sol + h.T@sol)
+
+class QuadraticModel(QuadraticMixIn, EqcModel):
+    """ Provides a quadratic operator and device sum constraint support """
+
+    def __init__(self, C : np.ndarray, J : np.ndarray, sum_constraint : float):
+        self._C = C
+        self._J = J
+        self._sum_constraint = sum_constraint
+    
+    @property
+    def H(self):
+        return self._C, self._J
+    
+    def check_constraint(self, solution: np.array) -> bool:
+        """ Evaluate the solution against the original sum constraint """
+        return np.sum(solution) == self.sum_constraint
+    
+    @property
+    def sum_constraint(self) -> int:
+        """ Integer value which all qudits must sum to.
+        The value must be less than or equal to  n * base for
+        the model to make sense. """
+
+        return self._sum_constraint
+
+    @sum_constraint.setter
+    def sum_constraint(self, value : int):
+        self._sum_constraint = value

{eqc_models-0.9.8.data → eqc_models-0.10.0.data}/platlib/eqc_models/sequence/tsp.py

@@ -87,14 +87,22 @@ class MTZTSPModel(InequalitiesMixin, TSPModel):
     1
     >>> model.distance(3, 2)
     3
-    >>> solution = np.array([1, 0, 0, 1, 1, 0, 1, 2, 3, 4, 4, 2, 5])
+    >>> solution = np.array([1, 0, 0, 1, 1, 0, 1, 2, 3, 2, 2, 2, 5])
     >>> model.cost(solution)
     6
     >>> lhs, rhs = model.constraints
+    >>> lhs.shape
+    (10, 13)
+    >>> model.senses
+    ['EQ', 'EQ', 'EQ', 'EQ', 'EQ', 'EQ', 'LE', 'LE', 'LE', 'LE']
+    >>> rhs.shape
+    (10,)
     >>> (lhs@solution - rhs == 0).all()
     True
+    >>> model.upper_bound
+    array([1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3])
     >>> poly = model.polynomial
-    >>> poly.evaluate(solution) + model.alpha * model.offset
+    >>> poly.evaluate(solution) + model.penalty_multiplier * model.offset
     6.0
     >>> infeasible = np.array([0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 4, 2, 5])
     >>> Pl, Pq = -2 * rhs.T@lhs, lhs.T@lhs
@@ -102,15 +110,15 @@ class MTZTSPModel(InequalitiesMixin, TSPModel):
     0.0
     >>> Pl.T@infeasible + infeasible.T@Pq@infeasible + model.offset > 0
     True
-    >>> poly.evaluate(infeasible) + model.alpha * model.offset > 0
+    >>> poly.evaluate(infeasible) + model.penalty_multiplier * model.offset > 0
     True
-    >>> infeasible = 1 - np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-    >>> poly.evaluate(infeasible) + model.alpha * model.offset > 6
+    >>> infeasible = np.array([1, 1, 0, 1, 0, 0, 0, 1, 2, 2, 2, 0, 3])
+    >>> poly.evaluate(infeasible) + model.penalty_multiplier * model.offset > 6
     True
-    >>> val1 = poly.evaluate(infeasible) + model.alpha * model.offset
+    >>> val1 = poly.evaluate(infeasible) + model.penalty_multiplier * model.offset
     >>> model.penalty_multiplier *= 2
     >>> poly2 = model.polynomial
-    >>> val2 = poly2.evaluate(infeasible) + model.alpha * model.offset
+    >>> val2 = poly2.evaluate(infeasible) + model.penalty_multiplier * model.offset
     >>> val1 < val2
     True
 
@@ -121,53 +129,54 @@ class MTZTSPModel(InequalitiesMixin, TSPModel):
         self.variables = variables = []
         coefficients = []
         indices = []
+        # choose a depot node
+        self.depot = depot = list(self.nodes)[0]
+        self.var_ub = var_ub = []
         for (u, v) in D.keys():
             varname = f"x_{u}_{v}"
             varidx = len(variables)
             variables.append(varname)
+            var_ub.append(1)
             indices.append((0, varidx+1))
             coefficients.append(D[(u, v)])
         for u in self.nodes:
             variables.append(f"s_{u}")
+            var_ub.append(self.N - 1)
         self.coefficients = coefficients
         self.indices = indices
         self.max_order = 2
+        # Build the constraints: Two constraints for every node, one for the
+        # edge chosen to enter and another for the edge chosen to leave.
+        # One constraint for every edge not leading to the depot.
 
-    @property
-    def constraints(self) -> Tuple[np.ndarray, np.ndarray]:
-        """ 
-        Build the constraints: Two constraints for every node, one for the
-        edge chosen to enter and another for the edge chosen to leave.
-        One constraint for every edge not leading to the depot.
-
-        Returns: 2-Tuple of numpy arrays, one as lefthand side and the other
-                 for the righthand side. $Ax = b$
-
-        """
-        # choose a depot node
-        depot = list(self.nodes)[0]
         depot_in = [uv for uv in self.edges if uv[-1] == depot]
         m = 2*self.N+len(self.edges) - len(depot_in)
-        lhs = np.ndarray((m, self.n), dtype=np.int32)
-        rhs = np.ndarray((m,), dtype=np.int32)
+        n = len(self.variables)
+        lhs = np.zeros((m, n), dtype=np.int64)
+        rhs = np.zeros((m,), dtype=np.int64)
         senses = ["EQ" for i in range(m)]
+        N = self.N
+        M = int(np.sqrt(N)) #  N // 2
+        # scaling these coefficients
         for idx, node in enumerate(self.nodes):
-            rhs[idx] = 1
-            rhs[self.N + idx] = 1
+            rhs[idx] = M
+            rhs[self.N + idx] = M
             for (u, v) in self.edges:
                 if v == node:
                     varname = f"x_{u}_{v}"
                     varidx = self.variables.index(varname)
-                    lhs[idx, varidx] = 1
+                    lhs[idx, varidx] = M
                 elif u == node:
                     varname = f"x_{u}_{v}"
                     varidx = self.variables.index(varname)
-                    lhs[self.N+idx, varidx] = 1
+                    lhs[self.N+idx, varidx] = M
         # build these subtour elimination constraints
         # s_i - s_j + N x_{ij} <= N - 1
         idx = 0
         for (u, v) in self.edges:
             if v != depot:
+                varname = f"x_{u}_{v}"
+                varidx = self.variables.index(varname)
                 senses[2*self.N + idx] = "LE"
                 lhs[2*self.N + idx, varidx] = self.N - 1
                 vidx = self.variables.index(f"s_{v}")
@@ -180,8 +189,6 @@ class MTZTSPModel(InequalitiesMixin, TSPModel):
         self.senses = senses
         self.lhs = lhs
         self.rhs = rhs
-        # let the superclass handle the rest
-        return super(MTZTSPModel, self).constraints
 
     def cost(self, solution : np.ndarray) -> float:
         """ 
@@ -206,12 +213,9 @@ class MTZTSPModel(InequalitiesMixin, TSPModel):
     def upper_bound(self) -> np.ndarray:
         """ 
         For all route variables, the domain is {0, 1}. The sequence variables
-        can take on values in [0, 1, 2, ..., N]. 
+        can take on values in [0, 1, 2, ..., N-1]. 
         
         """
-        # Since the sequence variables are all required, but the route variables
-        # are not, just reference the count from the end to specify the sequence vars
-        upper_bound = np.ones((len(self.variables),))
-        upper_bound[-self.N:] = self.N
-        return upper_bound
+        slacks = len([sense for sense in self.senses if sense != "EQ"])
+        return np.array(self.var_ub + [self.N for i in range(slacks)])
 

eqc_models-0.10.0.data/platlib/eqc_models/solvers/eqcdirect.py

@@ -0,0 +1,160 @@
+# (C) Quantum Computing Inc., 2024.
+from typing import Dict
+import logging
+import numpy as np
+from eqc_direct.client import EqcClient
+from eqc_models.base.base import ModelSolver, EqcModel
+
+log = logging.getLogger(name=__name__)
+
+
+class EqcDirectMixin:
+    """
+    This class provides an instance method and property that
+    manage the direct connection to a QCi device.
+
+    """
+
+    ip_addr = None
+    port = None
+
+    def connect(self, ip_addr: str, port: str) -> str:
+        """
+        Explicitly set device address; if environment is
+        configured with the connection, this call is not required.
+
+        Parameters
+        ------------
+
+        ip_addr: The IP address of the device.
+
+        port: The port number of the device.
+
+        Parameters
+        ------------
+        The status.
+
+        """
+        self.ip_addr = ip_addr
+        self.port = port
+        client = self.client
+        return client.system_status()["status_desc"]
+
+    @property
+    def client(self):
+        params = {}
+        if self.ip_addr is not None:
+            params["ip_address"] = self.ip_addr
+        if self.port is not None:
+            params["port"] = self.port
+        return EqcClient(**params)
+
+
+class EqcDirectSolver(ModelSolver, EqcDirectMixin):
+    """
+    This class provides an instance method for direct submission
+    of jobs to QCi devices.
+
+    """
+
+    def solve(
+        self,
+        model: EqcModel,
+        relaxation_schedule: int = 2,
+        precision: float = 1.0,
+    ) -> Dict:
+        """Parameters
+        -------------
+        model: An EqcModel instance.
+
+        relaxation_schedule: A predefined schedule indicator which
+        sets parameters on the device to control the sampling through
+        photon measurement; default is 2.
+
+        precision: A value which, when not None, indicates
+        the numerical precision desired in the solution: 1 for
+        integer, 0.1 for tenths place, 0.01 for hundreths and None for
+        raw; default is 1.0.
+
+        Returns
+        ---------
+        Json response from the solver.
+
+        """
+        poly_coefficients, poly_indices = model.sparse
+        # print(poly_indices)
+        if model.machine_slacks > 0:
+            # add a single 0 coefficient entry as the next-highest index
+            highest_idx = int(np.max(poly_indices))
+            # print("POLY HIGHEST", highest_idx)
+            for i in range(model.machine_slacks):
+                addtl_index = [0 for i in range(len(poly_indices[0]))]
+                addtl_index[-1] = highest_idx + i + 1
+                poly_indices = poly_indices.tolist() + [addtl_index]
+                poly_coefficients = poly_coefficients.tolist() + [0]
+        # print(poly_indices)
+        scval = model.sum_constraint
+
+        client = self.client
+        lock_id, start_ts, end_ts = client.wait_for_lock()
+        log.debug(
+            "Got device lock id %s. Wait time %f",
+            lock_id,
+            end_ts - start_ts,
+        )
+        resp = None
+        try:
+            log.debug(
+                "Calling device with parameters relaxation_schedule %d sum_constraint %s lock_id %s solution_precision %f",
+                relaxation_schedule,
+                scval,
+                lock_id,
+                precision,
+            )
+            resp = client.process_job(
+                poly_coefficients=poly_coefficients,
+                poly_indices=poly_indices,
+                relaxation_schedule=relaxation_schedule,
+                sum_constraint=scval,
+                lock_id=lock_id,
+                solution_precision=precision,
+            )
+            log.debug("Received response with status %s", resp["err_desc"])
+            log.debug(
+                "Runtime %f resulting in energy %f",
+                resp["runtime"],
+                resp["energy"],
+            )
+            log.debug(
+                "Distillation runtime %s resulting in energy %f",
+                resp["distilled_runtime"],
+                resp["distilled_energy"],
+            )
+        finally:
+            client.release_lock(lock_id=lock_id)
+        if resp is not None:
+            solution = resp["solution"]
+            energy = resp["energy"]
+            runtime = resp["runtime"]
+            dirac3_sol = np.array(solution)
+            log.debug(
+                "Energy %f Runtime %f Solution Size %i Solution Sum %f",
+                energy,
+                runtime,
+                len(dirac3_sol),
+                sum(dirac3_sol),
+            )
+        else:
+            raise RuntimeError("FAILED TO GET RESPONSE")
+        return resp
+
+
+class Dirac3DirectSolver(EqcDirectSolver):
+
+    """
+    Naming this for when when other devices are available and have
+    different requirements. For instance, Dirac-3 requires the
+    summation constraint parameter, but others might not. The same
+    could be true for relaxation schedule.
+
+    """

{eqc_models-0.9.8.data → eqc_models-0.10.0.data}/platlib/eqc_models/solvers/qciclient.py

@@ -5,6 +5,7 @@ import datetime
 import numpy as np
 from qci_client import QciClient
 from eqc_models.base.base import ModelSolver, EqcModel
+from eqc_models.base.operators import OperatorNotAvailableError
 
 log = logging.getLogger(name=__name__)
 
@@ -69,6 +70,8 @@ class QciClientMixin:
 
 class Dirac1Mixin:
     sampler_type = "dirac-1"
+    requires_operator = "qubo"
+    max_upper_bound = 1
     job_params_names = ["num_samples", "alpha", "atol"]
 
 class QuboSolverMixin:
@@ -108,12 +111,15 @@ class Dirac3Mixin:
     """
 
     sampler_type = "dirac-3"
+    requires_operator = "polynomial"
+    # this restriction is based on the physical limit of Dirac-3 S1
+    max_upper_bound = 10000
     job_params_names = [
         "num_samples",
         "solution_precision",
         "relaxation_schedule",
         "mean_photon_number",
-        "normalized_loss_rate",
+        "quantum_fluctuation_coefficient",
     ]
 
     def uploadJobFiles(self, client: QciClient, model: EqcModel):
@@ -262,6 +268,34 @@ class QciClientSolver(QciClientMixin, ModelSolver):
     def uploadJobFiles(self, client: QciClient, model: EqcModel):
         raise NotImplementedError("Subclass must override uploadJobFiles")
 
+    def checkModel(self, model):
+        """
+        Parameters
+        -------------
+
+        model: EqcModel
+            Instance of a model to validate against the solver requirements
+
+        This method raises an exception if the model supplied does not meet the requirements for the solver.
+        One of the validations is that the model supplies the operator that the solver uses. This is the
+        `qubo` operator for Dirac-1 and `polynomial` operator for Dirac-3. If the model does not supply 
+        the operator, then the solver cannot accept it and the method will fail with an explanation. 
+        Another validation is for the allowed upper bound of a model. For instance, solvers which only 
+        handle binary variables can only accept models with variabes having an upper bound of 1.
+
+        """
+        try:
+            hasattr(model, self.requires_operator)
+        except OperatorNotAvailableError:
+            msg = (f"Class {model.__class__.__name__} does not provide a " 
+                   f"{self.requires_operator} operator")
+            raise ValueError(msg)
+        if np.max(model.upper_bound) > self.max_upper_bound:
+            msg = (f"Instance of {model.__class__.__name__} has greater "
+                   f"upper bound on variables than {self.__class__.__name__} "
+                   "supports")
+            raise ValueError(msg)
+
     def solve(
         self,
         model: EqcModel,
@@ -306,6 +340,7 @@ class QciClientSolver(QciClientMixin, ModelSolver):
  
         """
 
+        self.checkModel(model)
         job_config = {}
         job_config.update(
             {"num_samples": num_samples, "device_type": self.sampler_type}
@@ -439,7 +474,7 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
         num_samples: int = 1,
         wait: bool = True,
         mean_photon_number: float = None,
-        normalized_loss_rate: int = None,
+        quantum_fluctuation_coefficient: int = None,
         **job_kwargs,
     ):
         """
@@ -476,7 +511,7 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
             Modify this value to control the relaxation schedule more
             precisely than the four presets given in schedules 1
             through 4. Allowed values are decimals between 0.1 and 2.
-        normalized_loss_rate : int 
+        quantum_fluctuation_coefficient: int 
             an integer value which Sets the amount of loss introduced
             into the system for each loop during the measurement process.
             Modify this value to control the relaxation schedule more
@@ -494,7 +529,7 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
                 )
             job_kwargs["relaxation_schedule"] = relaxation_schedule
             job_kwargs["mean_photon_number"] = mean_photon_number
-            job_kwargs["normalized_loss_rate"] = normalized_loss_rate
+            job_kwargs["quantum_fluctuation_coefficient"] = quantum_fluctuation_coefficient
             job_kwargs["solution_precision"] = solution_precision
             job_type = "sample-" + self.job_type
             return super().solve(
@@ -509,7 +544,7 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
 
         else:
             job_kwargs["mean_photon_number"] = mean_photon_number
-            job_kwargs["normalized_loss_rate"] = normalized_loss_rate
+            job_kwargs["quantum_fluctuation_coefficient"] = quantum_fluctuation_coefficient
             job_kwargs["relaxation_schedule"] = relaxation_schedule
             job_kwargs["num_levels"] = ub = [val + 1 for val in model.upper_bound.tolist()]
             job_type = "sample-" + self.job_type + "-integer"
@@ -551,7 +586,7 @@ class Dirac3IntegerCloudSolver(Dirac3Mixin, QciClientSolver):
               num_samples: int = 1,
               wait: bool = True,
               mean_photon_number: float = None,
-              normalized_loss_rate: int = None,
+              quantum_fluctuation_coefficient: int = None,
               **job_kwargs,
               ):
         """
@@ -579,7 +614,7 @@ class Dirac3IntegerCloudSolver(Dirac3Mixin, QciClientSolver):
             Modify this value to control the relaxation schedule more
             precisely than the four presets given in schedules 1
             through 4. Allowed values are decimals between 0.1 and 2.
-        normalized_loss_rate : int 
+        quantum_fluctuation_coefficient: int 
             an integer value which Sets the amount of loss introduced
             into the system for each loop during the measurement process.
             Modify this value to control the relaxation schedule more
@@ -601,7 +636,7 @@ class Dirac3IntegerCloudSolver(Dirac3Mixin, QciClientSolver):
             num_samples=num_samples,
             wait=wait,
             mean_photon_number=mean_photon_number,
-            normalized_loss_rate=normalized_loss_rate,
+            quantum_fluctuation_coefficient=quantum_fluctuation_coefficient,
             relaxation_schedule=relaxation_schedule,
             num_levels=[val + 1 for val in model.upper_bound.tolist()],
             **job_kwargs,
@@ -638,7 +673,7 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
         num_samples: int = 1,
         wait: bool = True,
         mean_photon_number: float = None,
-        normalized_loss_rate: int = None,
+        quantum_fluctuation_coefficient: int = None,
         **job_kwargs,
         ):
         """
@@ -673,7 +708,7 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
             Modify this value to control the relaxation schedule more
             precisely than the four presets given in schedules 1
             through 4. Allowed values are decimals between 0.1 and 2.
-        normalized_loss_rate : int 
+        quantum_fluctuation_coefficient: int 
             an integer value which Sets the amount of loss introduced
             into the system for each loop during the measurement process.
             Modify this value to control the relaxation schedule more
@@ -701,7 +736,7 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
             sum_constraint=sum_constraint,
             relaxation_schedule=relaxation_schedule,
             mean_photon_number=mean_photon_number,
-            normalized_loss_rate=normalized_loss_rate,
+            quantum_fluctuation_coefficient=quantum_fluctuation_coefficient,
             **job_kwargs,
         )