Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
model = Rosenbrock(request.param)
x = np.ones(model.nvar)
x[1::2] = -1
dcheck = DerivativeChecker(model, x, tol=1.0e-4)
dcheck.check()
dcheck.check(cheap_check=True, hess=False)
return dcheck
def test_rosenbrock(rosenbrock_checker):
assert (len(rosenbrock_checker.grad_errs) == 0)
assert (len(rosenbrock_checker.hess_errs) == 0)
assert (len(rosenbrock_checker.cheap_grad_errs) == 0)
class Erroneous(NLPModel):
def __init__(self, nvar, **kwargs):
kwargs.pop("m", None)
super(Erroneous, self).__init__(nvar, m=1, **kwargs)
def obj(self, x):
return 0.5 * np.dot(x, x)
def grad(self, x):
g = x.copy()
g[0] += 1 # error: should be x[0].
return g
def hess(self, x, *args, **kwargs):
obj_weight = kwargs.get('obj_weight', 1.0)
H = np.eye(self.nvar)
try:
from cysparse.sparse.ll_mat import LLSparseMatrix
import cysparse.common_types.cysparse_types as types
except:
print "CySparse is not installed!"
from nlp.model.nlpmodel import NLPModel
from nlp.model.snlp import SlackModel
from nlp.model.qnmodel import QuasiNewtonModel
from pykrylov.linop import CysparseLinearOperator
import numpy as np
class CySparseNLPModel(NLPModel):
"""
An `NLPModel` where sparse matrices are returned as CySparse matrices.
The `NLPModel`'s `jac` and `hess` methods should return sparse
Jacobian and Hessian in coordinate format: (vals, rows, cols).
"""
def hess(self, *args, **kwargs):
"""Evaluate Lagrangian Hessian at (x, z).
Note that `rows`, `cols` and `vals` must represent a LOWER triangular
sparse matrix in the coordinate format (COO).
"""
vals, rows, cols = super(CySparseNLPModel, self).hess(*args, **kwargs)
H = LLSparseMatrix(size=self.nvar, size_hint=vals.size,
store_symmetric=True, itype=types.INT64_T,
dtype=types.FLOAT64_T)
def __init__(self, model, **kwargs):
if not isinstance(model, NLPModel):
raise TypeError("The model in `model` should be a `NLPModel`"
"or a derived class of it.")
super(SciPySlackModel, self).__init__(model)
try:
from pysparse.sparse import PysparseMatrix as psp
except ImportError:
print "PySparse is not installed!"
from nlp.model.nlpmodel import NLPModel
from nlp.model.snlp import SlackModel
from nlp.model.qnmodel import QuasiNewtonModel
from pykrylov.linop.linop import PysparseLinearOperator
import numpy as np
class PySparseNLPModel(NLPModel):
"""An `NLPModel` where sparse matrices are returned in PySparse format.
The `NLPModel`'s `jac` and `hess` methods should return that sparse
Jacobian and Hessian in coordinate format: (vals, rows, cols).
"""
def hess(self, *args, **kwargs):
"""Evaluate Lagrangian Hessian at (x, z)."""
vals, rows, cols = super(PySparseNLPModel, self).hess(*args, **kwargs)
H = psp(size=self.nvar, sizeHint=vals.size, symmetric=True)
H.put(vals, rows, cols)
return H
def jac(self, *args, **kwargs):
"""Evaluate constraints Jacobian at x."""
vals, rows, cols = super(PySparseNLPModel,
bot += model.nrangeC
self.tLL = range(bot, bot + model.nlowerB)
bot += model.nlowerB
self.tLR = range(bot, bot + model.nrangeB)
bot += model.nrangeB
self.tUU = range(bot, bot + model.nupperB)
bot += model.nupperB
self.tUR = range(bot, bot + model.nrangeB)
n = model.n + n_con_low + n_con_upp + n_var_low + n_var_upp
m = model.m + model.nrangeC + n_var_low + n_var_upp
Lvar = np.zeros(n)
Lvar[:model.n] = -np.inf * np.ones(model.n)
Uvar = np.inf * np.ones(n)
NLPModel.__init__(self, n=n, m=m, name='slack-' + model.name,
Lvar=Lvar, Uvar=Uvar, Lcon=np.zeros(m))
# Redefine primal and dual initial guesses
self.x0 = np.empty(self.n)
self.x0[:model.n] = model.x0[:]
self.x0[model.n:] = 0
self.pi0 = np.empty(self.m)
self.pi0[:model.m] = model.pi0[:]
self.pi0[model.m:] = 0
return
# -*- coding: utf-8 -*-
"""A slack framework for NLP.py."""
import numpy as np
from nlp.model.nlpmodel import NLPModel
__docformat__ = 'restructuredtext'
class SlackModel(NLPModel):
u"""General framework for converting a nonlinear optimization problem to a
form using slack variables.
Original problem::
cᴸ ≤ c(x)
c(x) ≤ cᵁ
cᴿᴸ ≤ c(x) ≤ cᴿᵁ
c(x) = cᴱ
l ≤ x ≤ u
is transformed to::
c(x) - sᴸ = 0
c(x) - sᵁ = 0
c(x) - sᴿ = 0
"""Models with sparse matrices in SciPy coordinate (COO) format."""
from scipy import sparse as sp
from nlp.model.nlpmodel import NLPModel
from nlp.model.amplmodel import AmplModel
from nlp.model.snlp import SlackModel
from nlp.model.qnmodel import QuasiNewtonModel
from pykrylov.linop.linop import linop_from_ndarray
import numpy as np
class SciPyNLPModel(NLPModel):
"""`NLPModel` with sparse matrices in SciPy coordinate (COO) format.
The `NLPModel`'s :meth:`jac` and :meth:`hess` methods
should return that sparse Jacobian and Hessian in coordinate format:
(vals, rows, cols).
"""
def hess(self, *args, **kwargs):
"""Evaluate Lagrangian Hessian."""
vals, rows, cols = super(SciPyNLPModel, self).hess(*args, **kwargs)
return sp.coo_matrix((vals, (rows, cols)),
shape=(self.nvar, self.nvar))
def jac(self, *args, **kwargs):
"""Evaluate sparse constraints Jacobian."""
if self.ncon == 0: # SciPy cannot create sparse matrix of size 0.
"""Models with quasi-Newton Hessian approximation."""
from nlp.model.nlpmodel import NLPModel
__docformat__ = 'restructuredtext'
class QuasiNewtonModel(NLPModel):
"""`NLPModel with a quasi-Newton Hessian approximation."""
def __init__(self, *args, **kwargs):
"""Instantiate a model with quasi-Newton Hessian approximation.
:keywords:
:H: the `class` of a quasi-Newton linear operator.
This keyword is mandatory.
Keywords accepted by the quasi-Newton class will be passed
directly to its constructor.
"""
super(QuasiNewtonModel, self).__init__(*args, **kwargs)
qn_cls = kwargs.pop('H')
self._H = qn_cls(self.nvar, **kwargs)
from hsl.solvers.pyma27 import PyMa27Solver as LBLContext
from hsl.scaling.mc29 import mc29ad
from pykrylov.linop import PysparseLinearOperator
from nlp.tools.norms import norm2, norm_infty, normest
from nlp.tools.timing import cputime
import logging
# for slack model
from nlp.model.nlpmodel import NLPModel
from nlp.model.qnmodel import QuasiNewtonModel
from pysparse.sparse.pysparseMatrix import PysparseMatrix
import numpy as np
# CQP needs equality constraints and bounds on variables as s>=0
class SlackModel(NLPModel):
"""Framework for converting an optimization problem to a form using slacks.
In the latter problem, the only inequality constraints are bounds on
the slack variables. The other constraints are (typically) nonlinear
equalities.
The order of variables in the transformed problem is as follows:
1. x, the original problem variables.
2. sL = [ sLL | sLR ], sLL being the slack variables corresponding to
general constraints with a lower bound only, and sLR being the slack
variables corresponding to the 'lower' side of range constraints.
3. sU = [ sUU | sUR ], sUU being the slack variables corresponding to
general constraints with an upper bound only, and sUR being the slack
# -*- coding: utf-8 -*-
"""Restriction of models to lines."""
from nlp.model.nlpmodel import NLPModel
from nlp.tools.utils import where, Min, Max
import numpy as np
class C1LineModel(NLPModel):
u"""Restriction of a C¹ model to a line.
An instance of this class is a model representing the original model
restricted to the line x + td. More precisely, if the original objective
is f: ℝⁿ → ℝ, then, given x ∈ ℝⁿ and d ∈ ℝⁿ (d≠0) a fixed direction, the
objective of the restricted model is ϕ: ℝ → ℝ defined by
ϕ(t) := f(x + td).
Similarly, if the original constraints are c: ℝⁿ → ℝᵐ, the constraints of
the restricted model are γ: ℝ → ℝᵐ defined by
γ(t) := c(x + td).
The functions f and c are only assumed to be C¹, i.e., only values and
first derivatives of ϕ and γ are defined.