pyMOTO 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

pymoto/common/mma.py

@@ -28,20 +28,50 @@ def residual(x, y, z, lam, xsi, eta, mu, zet, s, upp, low, P0, P1, Q0, Q1, epsi,
     ])
 
 
-def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
-    """ This function subsolv solves the MMA subproblem
-    minimize   SUM[ p0j/(uppj-xj) + q0j/(xj-lowj) ] + a0*z +
-             + SUM[ ci*yi + 0.5*di*(yi)^2 ],
-    subject to SUM[ pij/(uppj-xj) + qij/(xj-lowj) ] - ai*z - yi <= bi,
-               alfaj <=  xj <=  betaj,  yi >= 0,  z >= 0.
-    Input:  m, n, low, upp, alfa, beta, p0, q0, P, Q, a0, a, b, c, d.
-    Output: xmma,ymma,zmma, slack variables and Lagrange multiplers.
+def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d, x0=None):
+    r""" This function solves the MMA subproblem
+
+    minimize   f_0(\vec{x}) + a_0*z + \sum_i^m[ c_i*y_i + 1/2*d_i*y_i^2 ],
+    subject to f_i(\vec{x}) - a_i*z - y_i <= b_i,   for i = 1, ..., m
+               alfa_j <=  x_j <=  beta_j,  for j = 1, ..., n
+               y_i >= 0,  for i = 1, ..., m
+               z >= 0.
+
+    where:
+        MMA approximation: :math:`f_i(\vec{x}) = \sum_j\left( p_{ij}/(upp_j-x_j) + q_{ij}/(x_j-low_j) \right)`
+        m: The number of general constraints
+        n: The number of variables in :math:`\vec{x}`
+
+    Args:
+        epsimin: Solution tolerance on maximum residual
+        low: Column vector with the lower asymptotes
+        upp: Column vector with the upper asymptotes
+        alfa: Vector with the lower bounds for the variables :math:`\vec{x}`
+        beta: Vector with the upper bounds for the variables :math:`\vec{x}`
+        P: Upper asymptotic amplitudes
+        Q: Lower asymptotic amplitudes
+        a0: The constants :math:`a_0` in the term :math:`a_0\cdot z`
+        a: Vector with the constants :math:`a_i` in the terms :math:`a_i \cdot z`
+        c: Vector with the constants :math:`c_i` in the terms :math:`c_i \cdot y_i`
+        d: Vector with the constants :math:`d_i` in the terms :math:`0.5 \cdot d_i \cdot y_i^2`
+        x0 (optional): Initial guess, in case not given :math:`x_0 = (\alpha + \beta)/2` is used
+
+    Returns:
+        x: Vector with the optimal values of the variables :math:`\vec{x}` in the current MMA subproblem
+        y: Vector with the optimal values of the variables :math:`y_i` in the current MMA subproblem
+        z: Scalar with the optimal value of the variable :math:`z` in the current MMA subproblem
+        lam: Lagrange multipliers for the :math:`m` general MMA constraints
+        xsi: Lagrange multipliers for the :math:'n' constraints :math:`alfa_j - x_j <= 0`
+        eta: Lagrange multipliers for the :math:'n' constraints :math:`x_j - beta_j <= 0`
+        mu: Lagrange multipliers for the :math:`m` constraints :math:`-y_i <= 0`
+        zet: Lagrange multiplier for the single constraint :math:`-z <= 0`
+        s: Slack variables for the m general MMA constraints
     """
 
     n, m = len(alfa), len(a)
     epsi = 1.0
     maxittt = 400
-    x = 0.5 * (alfa + beta)
+    x = 0.5 * (alfa + beta) if x0 is None else np.clip(x0, alfa+1e-10, beta-1e-10)  # Design variables
     y = np.ones(m)
     z = 1.0
     lam = np.ones(m)
@@ -168,8 +198,7 @@ def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
             sold = s.copy()
 
             # Do linesearch
-            itto = 0
-            while itto < maxittt:
+            for itto in range(maxittt):
                 # Find new set of variables with stepsize
                 x[:] = xold + steg * dx
                 y[:] = yold + steg * dy
@@ -184,14 +213,13 @@ def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
                 residu = residual(x, y, z, lam, xsi, eta, mu, zet, s, upp, low, P0, P1, Q0, Q1, epsi, a0, a, b, c, d, alfa, beta)
                 if np.linalg.norm(residu) < residunorm:
                     break
-                itto += 1
                 steg /= 2  # Reduce stepsize
 
             residunorm = np.linalg.norm(residu)
             residumax = np.max(np.abs(residu))
 
         if ittt > maxittt - 2:
-            print(f"MMA Subsolver: itt = {ittt}, at epsi = {epsi}")
+            print(f"MMA Subsolver: itt = {ittt}, at epsi = {'%.3e'%epsi}")
         # decrease epsilon with factor 10
         epsi /= 10
 
@@ -200,8 +228,7 @@ def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
 
 
 class MMA:
-    """
-    Block for the MMA algorithm
+    r""" Class for the MMA optimization algorithm
     The design variables are set by keyword <variables> accepting a list of variables.
     The responses are set by keyword <responses> accepting a list of signals.
     If none are given, the internal sig_in and sig_out are used.
@@ -219,11 +246,16 @@ class MMA:
         xmin: Minimum design variable (can be a vector)
         xmax: Maximum design variable (can be a vector)
         fn_callback: A function that is called just before calling the response() in each iteration
-        verbosity: 0 - No prints, 1 - Only convergence message, 2 - Convergence and iteration info, 3 - Extended info
+        verbosity: Level of information to print
+          0 - No prints
+          1 - Only convergence message
+          2 - Convergence and iteration info (default)
+          3 - Additional info on variables
+          4 - Additional info on sensitivity information
 
     """
 
-    def __init__(self, function, variables, responses, tolx=1e-4, tolf=0.0, move=0.1, maxit=100, xmin=0.0, xmax=1.0, fn_callback=None, verbosity=0, **kwargs):
+    def __init__(self, function, variables, responses, tolx=1e-4, tolf=0.0, move=0.1, maxit=100, xmin=0.0, xmax=1.0, fn_callback=None, verbosity=2, **kwargs):
         self.funbl = function
         self.verbosity = verbosity
 
@@ -246,19 +278,15 @@ class MMA:
 
         self.a0 = kwargs.get("a0", 1.0)
 
-        self.epsimin = kwargs.get("epsimin", 1e-7)  # Or 1e-7 ?? witout sqrt(m+n) or 1e-9
-        self.raa0 = kwargs.get("raa0", 1e-5)
-
+        self.epsimin = kwargs.get("epsimin", 1e-10)  # Or 1e-7 ?? witout sqrt(m+n) or 1e-9
         self.cCoef = kwargs.get("cCoef", 1e3)  # Svanberg uses 1e3 in example? Old code had 1e7
 
-        # Not used
-        self.dxmin = kwargs.get("dxmin", 1e-5)
-
         self.albefa = kwargs.get("albefa", 0.1)
         self.asyinit = kwargs.get("asyinit", 0.5)
         self.asyincr = kwargs.get("asyincr", 1.2)
         self.asydecr = kwargs.get("asydecr", 0.7)
         self.asybound = kwargs.get("asybound", 10.0)
+        self.mmaversion = kwargs.get("mmaversion", "Svanberg2007")  # Options are Svanberg1987, Svanberg2007
 
         self.ittomax = kwargs.get("ittomax", 400)
 
@@ -282,7 +310,6 @@ class MMA:
         self.d = np.ones(self.m)
         self.gold1 = np.zeros(self.m + 1)
         self.gold2 = self.gold1.copy()
-        self.rho = self.raa0 * np.ones(self.m + 1)
 
     def response(self):
         change = 1
@@ -301,8 +328,7 @@ class MMA:
                 self.xmin[self.cumlens[i]:self.cumlens[i+1]] = xminvals[i]
 
         if len(self.xmin) != self.n:
-            raise RuntimeError(
-                "Length of the xmin vector not correct ({} != {})".format(len(self.xmin), self.n))
+            raise RuntimeError(f"Length of the xmin vector ({len(self.xmin)}) should be equal to # design variables ({self.n})")
 
         if not hasattr(self.xmax, '__len__'):
             self.xmax = self.xmax * np.ones_like(xval)
@@ -313,17 +339,19 @@ class MMA:
                 self.xmax[self.cumlens[i]:self.cumlens[i + 1]] = xmaxvals[i]
 
         if len(self.xmax) != self.n:
-            raise RuntimeError("Length of the xmax vector not correct ({} != {})".format(len(self.xmax), self.n))
+            raise RuntimeError(f"Length of the xmax vector ({len(self.xmax)}) should be equal to # design variables ({self.n})")
 
-        # Set movelimit in case of multiple
         if hasattr(self.move, '__len__'):
-            if len(self.move) == len(self.variables):
-                movevals = self.move
+            # Set movelimit in case of multiple are given
+            move_input = np.asarray(self.move).copy()
+            if move_input.size == len(self.variables):
                 self.move = np.zeros_like(xval)
-                for i in range(len(movevals)):
-                    self.move[self.cumlens[i]:self.cumlens[i + 1]] = movevals[i]
+                for i in range(move_input.size):
+                    self.move[self.cumlens[i]:self.cumlens[i + 1]] = move_input[i]
             elif len(self.move) != self.n:
-                raise RuntimeError("Length of the move vector not correct ({} != {})".format(len(self.move), self.n))
+                raise RuntimeError(f"Length of the move vector ({len(self.move)}) should be equal to number of "
+                                   f"design variable signals ({len(self.variables)}) or "
+                                   f"total number of design variables ({self.n}).")
 
         fcur = 0.0
         while self.iter < self.maxIt:
@@ -333,12 +361,9 @@ class MMA:
             # Set the new states
             for i, s in enumerate(self.variables):
                 if self.cumlens[i+1]-self.cumlens[i] == 1:
-                    try:
-                        s.state[:] = xval[self.cumlens[i]]
-                    except TypeError:
-                        s.state = xval[self.cumlens[i]]
+                    s.state = xval[self.cumlens[i]]
                 else:
-                    s.state[:] = xval[self.cumlens[i]:self.cumlens[i+1]]
+                    s.state = xval[self.cumlens[i]:self.cumlens[i+1]]
 
             if self.fn_callback is not None:
                 self.fn_callback()
@@ -346,19 +371,11 @@ class MMA:
             # Calculate response
             self.funbl.response()
 
-            # Update the states
-            for i, s in enumerate(self.variables):
-                if self.cumlens[i+1]-self.cumlens[i] == 1:
-                    try:
-                        xval[self.cumlens[i]] = s.state[:]
-                    except (TypeError, IndexError):
-                        xval[self.cumlens[i]] = s.state
-                else:
-                    xval[self.cumlens[i]:self.cumlens[i+1]] = s.state[:]
-
             # Save response
             f = ()
             for s in self.responses:
+                if np.size(s.state) != 1:
+                    raise TypeError("State of responses must be scalar.")
                 f += (s.state, )
 
             # Check function change convergence criterion
@@ -388,27 +405,48 @@ class MMA:
                 # Reset sensitivities for the next response
                 self.funbl.reset()
 
-            # Display info on variables
             if self.verbosity >= 3:
+                # Display info on variables
+                show_sensitivities = self.verbosity >= 4
+                msg = ""
                 for i, s in enumerate(self.variables):
-                    isscal = self.cumlens[i + 1] - self.cumlens[i] == 1
-                    msg = "{0:>10s} = ".format(s.tag)
-                    if isscal:
-                        try:
-                            msg += "         {0: .3e}         ".format(s.state)
-                        except TypeError:
-                            msg += "         {0: .3e}         ".format(s.state[0])
+                    if show_sensitivities:
+                        msg += "{0:>10s} = ".format(s.tag[:10])
                     else:
-                        msg += "[{0: .3e} ... {1: .3e}] ".format(min(s.state), max(s.state))
-                    for j, s_out in enumerate(self.responses):
-                        msg += "| {0:>10s}/{1:10s} = ".format("d"+s_out.tag, "d"+s.tag)
-                        if isscal:
-                            msg += "         {0: .3e}         ".format(df[j][self.cumlens[i]])
+                        msg += f"{s.tag} = "
+
+                    # Display value range
+                    fmt = '% .2e'
+                    minval, maxval = np.min(s.state), np.max(s.state)
+                    mintag, maxtag = fmt % minval, fmt % maxval
+                    if mintag == maxtag:
+                        if show_sensitivities:
+                            msg += f"       {mintag}      "
                         else:
-                            msg += "[{0: .3e} ... {1: .3e}] ".format(min(df[j][self.cumlens[i]:self.cumlens[i+1]]), max(df[j][self.cumlens[i]:self.cumlens[i+1]]))
-                    print(msg)
+                            msg += f" {mintag}"
+                    else:
+                        sep = '…' if len(s.state) > 2 else ','
+                        msg += f"[{mintag}{sep}{maxtag}]"
+                        if show_sensitivities:
+                            msg += " "
+
+                    if show_sensitivities:
+                        # Display info on sensivity values
+                        for j, s_out in enumerate(self.responses):
+                            msg += "| {0:s}/{1:11s} = ".format("d" + s_out.tag, "d" + s.tag[:10])
+                            minval = np.min(df[j][self.cumlens[i]:self.cumlens[i+1]])
+                            maxval = np.max(df[j][self.cumlens[i]:self.cumlens[i+1]])
+                            mintag, maxtag = fmt % minval, fmt % maxval
+                            if mintag == maxtag:
+                                msg += f"       {mintag}      "
+                            else:
+                                sep = '…' if self.cumlens[i + 1] - self.cumlens[i] > 2 else ','
+                                msg += f"[{mintag}{sep}{maxtag}] "
+                        msg += '\n'
+                    elif i != len(self.variables)-1:
+                        msg += ', '
+                print(msg)
 
-            self.iter += 1
             xnew, change = self.mmasub(xval.copy(), np.hstack(f), np.vstack(df))
 
             # Stopping criteria on step size
@@ -419,6 +457,7 @@ class MMA:
                 break
 
             xval = xnew
+            self.iter += 1
 
     def mmasub(self, xval, g, dg):
         if self.dx is None:
@@ -426,57 +465,6 @@ class MMA:
         if self.offset is None:
             self.offset = self.asyinit * np.ones(self.n)
 
-        #      Minimize  f_0(x) + a_0*z + sum( c_i*y_i + 0.5*d_i*(y_i)^2 )
-        #    subject to  f_i(x) - a_i*z - y_i <= 0,  i = 1,...,m
-        #                xmin_j <= x_j <= xmax_j,    j = 1,...,n
-        #                z >= 0,   y_i >= 0,         i = 1,...,m
-        # *** INPUT:
-        #
-        #   m    = The number of general constraints.
-        #   n    = The number of variables x_j.
-        #  iter  = Current iteration number ( =1 the first time mmasub is called).
-        #  xval  = Column vector with the current values of the variables x_j.
-        #  xmin  = Column vector with the lower bounds for the variables x_j.
-        #  xmax  = Column vector with the upper bounds for the variables x_j.
-        #  xold1 = xval, one iteration ago (provided that iter>1).
-        #  xold2 = xval, two iterations ago (provided that iter>2).
-        #  f0val = The value of the objective function f_0 at xval.
-        #  df0dx = Column vector with the derivatives of the objective function
-        #          f_0 with respect to the variables x_j, calculated at xval.
-        #  fval  = Column vector with the values of the constraint functions f_i,
-        #          calculated at xval.
-        #  dfdx  = (m x n)-matrix with the derivatives of the constraint functions
-        #          f_i with respect to the variables x_j, calculated at xval.
-        #          dfdx(i,j) = the derivative of f_i with respect to x_j.
-        #  low   = Column vector with the lower asymptotes from the previous
-        #          iteration (provided that iter>1).
-        #  upp   = Column vector with the upper asymptotes from the previous
-        #          iteration (provided that iter>1).
-        #  a0    = The constants a_0 in the term a_0*z.
-        #  a     = Column vector with the constants a_i in the terms a_i*z.
-        #  c     = Column vector with the constants c_i in the terms c_i*y_i.
-        #  d     = Column vector with the constants d_i in the terms 0.5*d_i*(y_i)^2.
-        #
-
-        # *** OUTPUT:
-        #
-        #  xmma  = Column vector with the optimal values of the variables x_j
-        #          in the current MMA subproblem.
-        #  ymma  = Column vector with the optimal values of the variables y_i
-        #          in the current MMA subproblem.
-        #  zmma  = Scalar with the optimal value of the variable z
-        #          in the current MMA subproblem.
-        #  lam   = Lagrange multipliers for the m general MMA constraints.
-        #  xsi   = Lagrange multipliers for the n constraints alfa_j - x_j <= 0.
-        #  eta   = Lagrange multipliers for the n constraints x_j - beta_j <= 0.
-        #   mu   = Lagrange multipliers for the m constraints -y_i <= 0.
-        #  zet   = Lagrange multiplier for the single constraint -z <= 0.
-        #   s    = Slack variables for the m general MMA constraints.
-        #  low   = Column vector with the lower asymptotes, calculated and used
-        #          in the current MMA subproblem.
-        #  upp   = Column vector with the upper asymptotes, calculated and used
-        #          in the current MMA subproblem.
-
         # # ASYMPTOTES
         # Calculation of the asymptotes low and upp :
         # For iter = 1,2 the asymptotes are fixed depending on asyinit
@@ -519,36 +507,61 @@ class MMA:
         # # APPROXIMATE CONVEX SEPARABLE FUNCTIONS
         # Calculations of p0, q0, P, Q and b.
         # calculate the constant factor in calculations of pij and qij
+        # From: Svanberg(2007) - MMA and GCMMA, two methods for nonlinear optimization
+        dg_plus = np.maximum(+dg, 0)
+        dg_min = np.maximum(-dg, 0)
         dx2 = shift**2
-        P = dx2 * np.maximum(+dg, 0)
-        Q = dx2 * np.maximum(-dg, 0)
+        if '1987' in self.mmaversion:
+            # Original version
+            P = dx2 * dg_plus
+            Q = dx2 * dg_min
+        elif '2007' in self.mmaversion:
+            # Improved version -> Allows to use higher epsimin to get design variables closer to the bound.
+            P = dx2 * (1.001*dg_plus + 0.001*dg_min + 1e-5/self.dx)
+            Q = dx2 * (0.001*dg_plus + 1.001*dg_min + 1e-5/self.dx)
+        else:
+            raise ValueError("Only \"Svanberg1987\" or \"Svanberg2007\" are valid options")
 
         rhs = np.dot(P, 1 / shift) + np.dot(Q, 1 / shift) - g
         b = rhs[1:]
 
         # Solving the subproblem by a primal-dual Newton method
         epsimin_scaled = self.epsimin*np.sqrt(self.m + self.n)
-        xmma, ymma, zmma, lam, xsi, eta, mu, zet, s = subsolv(epsimin_scaled, self.low, self.upp, alfa, beta, P, Q, self.a0, self.a, b, self.c, self.d)
+        xmma, ymma, zmma, lam, xsi, eta, mu, zet, s = subsolv(epsimin_scaled, self.low, self.upp, alfa, beta, P, Q, self.a0, self.a, b, self.c, self.d, x0=xval)
 
         self.gold2, self.gold1 = self.gold1, g.copy()
         self.xold2, self.xold1 = self.xold1, xval.copy()
         change = np.average(abs(xval - xmma))
 
         if self.verbosity >= 2:
+            # Display iteration status message
             msgs = ["g{0:d}({1:s}): {2:+.4e}".format(i, s.tag, g[i]) for i, s in enumerate(self.responses)]
-            print("It. {0: 4d}, {1}".format(self.iter, ", ".join(msgs)))
+            max_infeasibility = max(g[1:])
+            is_feasible = max_infeasibility <= 0
+
+            feasibility_tag = 'f' if is_feasible else ' '
+            print("It. {0: 4d}, [{1:1s}] {2}".format(self.iter, feasibility_tag, ", ".join(msgs)))
 
-        if self.verbosity >=3:
-            # Print changes
-            printstr = "Changes: "
+        if self.verbosity >= 3:
+            # Report design feasibility
+            iconst_max = np.argmax(g[1:])
+            print(f"  | {np.sum(g[1:]>0)} / {len(g)-1} violated constraints, "
+                  f"max. violation ({self.responses[iconst_max+1].tag}) = {'%.2g'%g[iconst_max+1]}")
+
+            # Print design changes
+            change_msgs = []
             for i, s in enumerate(self.variables):
-                isscal = self.cumlens[i + 1] - self.cumlens[i] == 1
-                if isscal:
-                    chg = abs(xval[self.cumlens[i]] - xmma[self.cumlens[i]])
+                minchg = np.min(abs(xval[self.cumlens[i]:self.cumlens[i + 1]] - xmma[self.cumlens[i]:self.cumlens[i + 1]]))
+                maxchg = np.max(abs(xval[self.cumlens[i]:self.cumlens[i + 1]] - xmma[self.cumlens[i]:self.cumlens[i + 1]]))
+                fmt = '%.2g'
+                mintag, maxtag = fmt % minchg, fmt % maxchg
+
+                if mintag == maxtag:
+                    change_msgs.append(f"Δ({s.tag}) = {mintag}")
                 else:
-                    chg = np.average(abs(xval[self.cumlens[i]:self.cumlens[i + 1]] - xmma[self.cumlens[i]:self.cumlens[i + 1]]))
+                    change_msgs.append(f"Δ({s.tag}) = {mintag}…{maxtag}")
 
-                printstr += "{0:s} = {1:.3e}   ".format("Δ_"+s.tag, chg)
-            print(printstr)
+            print(f"  | Changes: {', '.join(change_msgs)}")
 
-        return xmma, change
+        return xmma, change
+