MOSEK Fusion API for Python: 数学优化软件包指南

需积分: 21 169 浏览量更新于2024-07-15 收藏 2.04MB PDF 举报

"mosek.fusion APIs手册，用于Python的MOSEKFusion API，是MOSEK优化工具的一部分，专门处理大规模数学优化问题，支持线性编程、混合整数编程和非线性优化等任务。" MOSEK Fusion API for Python是MOSEK公司提供的一种高级接口，旨在简化在Python环境中构建和解决大规模优化模型的过程。这个API特别适用于处理包含复杂结构和约束的优化问题。以下是对手册中关键内容的详细说明： 1. **设计概述**：这部分介绍Fusion API的设计理念，强调其易用性和灵活性，使得用户可以更直观地构建优化模型。 2. **Conic Modeling**：核心部分，讲解如何使用Fusion API构建锥形优化模型。锥形优化是一种强大的工具，可以处理各种类型的凸优化问题，包括线性、二次和更复杂的锥形约束。 - **模型**：模型对象是构建优化问题的基础，它包含了变量、约束和目标函数。 - **变量**：变量可以是连续的、整数的，也可以属于特定的锥形空间。 - **线性代数**：API支持向量和矩阵操作，用于构建线性表达式。 - **约束和目标**：用户可以方便地定义线性或非线性的约束，以及优化目标。 - **参数**：可以设置参数来调整求解器的行为。 - **堆叠和视图**：允许对数据进行高效的操作，如组合或切片。 - **向量化**：鼓励使用向量化操作，以提高代码效率。 - **再优化**：支持对已经解决的模型进行参数更改后的快速重优化。 3. **优化教程**：这部分通过实例详细介绍了不同类型的优化问题，包括： - **线性优化**：最基础的优化问题，只包含线性目标和约束。 - **锥形二次优化**：处理包含二次项的凸优化问题。 - **幂锥优化**：处理包含幂次关系的优化问题。 - **指数锥优化**：处理涉及指数和对数的优化问题。 - **半定规划**：处理矩阵变量的凸优化问题。 - **整数优化**：包含整数变量的优化问题，常用于组合优化。 - **几何规划**：一种特殊的优化形式，处理非线性关系。 - **基本函数库**：提供了一些预定义的函数，方便用户快速构建模型。 - **模型参数化和再优化**：探讨如何动态改变模型参数并重新优化。 - **问题修改和再优化**：说明如何在求解过程中修改问题并继续优化。 4. **Solver Interaction Tutorials**：这部分教程聚焦于与求解器的交互，包括如何访问解决方案、处理错误和异常。 MOSEK Fusion API for Python为用户提供了强大的工具来构建和解决各种类型的优化问题，无论是在学术研究还是工业应用中，都是一个宝贵的资源。通过深入学习和实践手册中的教程，用户可以有效地利用这个API解决实际的优化挑战。

6.2 Variables

Continuous variables can be scalars, vectors or higher-dimensional arrays. The are added to the model

with the method Model.variable which returns a representing object of type Variable . The shape of a

variable (number of dimensions and length in each dimension) has to be speciﬁed at creation. Optionally

a variable may be created in a restricted domain (by default variables are unbounded, that is in R). For

instance, to declare a variable 𝑥 ∈ R

𝑛

we could write

x = M.variable("x", n, Domain.greaterThan(0.))

A multi-dimensional variable is declared by specifying an array with all dimension sizes. Here is an

𝑛 × 𝑛 variable:

x = M.variable( [n,n], Domain.unbounded() )

The speciﬁcation of dimensions can also be part of the domain, as in this declaration of a symmetric

positive semideﬁnite variable of dimension 𝑛:

v = M.variable(Domain.inPSDCone(n));

Integer variables are speciﬁed with an additional domain modiﬁer. To add an integer variable 𝑧 ∈

[1, 10] we write

z= M.variable('z', Domain.integral(Domain.inRange(1.,10.)) )

The function Domain.binary is a shorthand for binary variables often appearing in combinatorial

problems:

y= M.variable('y', Domain.binary())

Integrality requirement can be switched on and oﬀ using the methods Variable.makeInteger and

Variable.makeContinuous .

A domain usually allows to specify the number of objects to be created. For example here is a

deﬁnition of 𝑚 symmetric positive semideﬁnite variables of dimension 𝑛 each. The actual variable x will

be of shape 𝑚 × 𝑛 × 𝑛 where each slice with ﬁxed ﬁrst coordinate is an 𝑛 × 𝑛 PSD:

x = M.variable(Domain.inPSDCone(n, m))

The Variable object provides the primal (Variable.level ) and dual (Variable.dual ) solution

values of the variable after optimization, and it enters in the construction of linear expressions involving

the variable.

6.3 Linear algebra

Linear expressions are constructed combining variables and matrices by linear operators. The result is an

object that represents the linear expression itself. Fusion only allows for those combinations of operators

and arguments that yield linear functions of the variables. Expressions have shapes and dimensions in

the same fashion as variables. For instance, if 𝑥 ∈ R

𝑛

and 𝐴 ∈ R

𝑚×𝑛

, then 𝐴𝑥 is a vector expression of

length 𝑚. Note, however, that the internal size of 𝐴𝑥 is 𝑚𝑛, because each entry is a linear combination

for which 𝑚 coeﬃcients have to be stored.

Expressions are concrete implementations of the virtual interface Expression . In typical situations,

however, all operations on expressions can be performed using the static methods and factory methods

of the class Expr .

Table 6.1: Linear Operators

Method Description

Expr.add Element-wise addition of two matrices

Expr.sub Element-wise subtraction of two matrices

Expr.mul Matrix or matrix-scalar multiplication

Expr.neg Sign inversion

Expr.outer Vector outer-product

Expr.dot Dot product

Expr.sum Sum over a given dimension

Expr.mulElm Element-wise multiplication

Expr.mulDiag Sum over the diagonal of a matrix which is the result of a matrix multiplication

Expr.constTerm Return a constant term

Operations on expressions must adhere to the rules of matrix algebra regarding dimensions; otherwise

a DimensionError exception will be thrown.

Expression can be composed, nested and used as building blocks in new expressions. For instance

𝐴𝑥 + 𝐵𝑦 can be implemented as:

Expr.add( Expr.mul(A,x), Expr.mul(B,y) )

For operations involving multiple variables and expressions the users should consider list-based meth-

ods. For instance, a clean way to write 𝑥 + 𝑦 + 𝑧 + 𝑤 would be:

Expr.add( [x, y, z, w] )

Note that a single variable (object of class Variable ) can also be used as an expression. Once

constructed, expressions are immutable.

6.4 Constraints and objective

Constraints are declared within an optimization model using the method Model.constraint . Every

constraint in Fusion has the form

Expression belongs to a Domain .

Objects of type Domain correspond roughly to the types of convex cones 𝒦 mentioned at the beginning

of this section. For instance, the following set of linear constraints

𝑥

+ 2𝑥

= 0

+ 𝑥

= 0

𝑥

= 0

(6.2)

could be declared as

A = [ [1.0, 2.0, 0.0],

[0.0, 1.0, 1.0],

[ 1.0, 0.0, 0.0] ]

x = M.variable("x",3,Domain.unbounded())

c = M.constraint( Expr.mul(A,x), Domain.equalsTo(0.0))

Note that the scalar domain Domain.equalsTo consisting of a single point 0 scales up to the dimension

of the expression and applies to all its elements. This allows many constraints to be comfortably expressed

in a vectorized form. See also Sec. 6.8.

The Constraint object provides the dual (Constraint.dual ) value of the constraint after optimiza-

tion and the primal value of the constraint expression (Constraint.level ).

The typical domains used to specify constraints are listed below. Note that they can also be used

directly at variable creation, whenever that makes sense.

Type Domain

Linear equality Domain.equalsTo

inequality ≤ Domain.lessThan

inequality ≥ Domain.greaterThan

two-sided bound Domain.inRange

Conic Quadratic quadratic cone Domain.inQCone

rotated quadratic cone Domain.inRotatedQCone

Other Conic exponential cone Domain.inPExpCone

power cone Domain.inPPowerCone (𝛼)

Semideﬁnite PSD matrix Domain.inPSDCone

Integral Integers in domain D Domain.integral (D)

{0, 1} Domain.binary

Having discussed variables and constraints we can ﬁnish by deﬁning the optimization objective with

Model.objective . The objective function is a scalar expression and the objective sense is speciﬁed by

the enumeration ObjectiveSense as either minimize or maximize. The typical linear objective function

𝑐

𝑇

𝑥 can be declared as

M.objective( ObjectiveSense.Minimize, Expr.dot(c,x) )

6.5 Matrices

At some point it becomes necessary to specify linear expressions such as 𝐴𝑥 where 𝐴 is a (large) constant

data matrix. Such coeﬃcient matrices can be represented in dense or sparse format. Dense matrices can

always be represented using the standard data structures for arrays and two-dimensional arrays built into

the language. Alternatively, or when sparsity can be exploited, matrices can be constructed as objects

of the class Matrix . This can have some advantages: a more generic code that can be ported across

platforms and can be used with both dense and sparse matrices without modiﬁcations.

Dense matrices are constructed with a variant of the static factory method Matrix.dense . The

values of all entries must be speciﬁed all at once and the resulting matrix is immutable. For example the

matrix

𝐴 =



1 2 3 4

5 6 7 8



can be deﬁned with:

A= [ [1, 2, 3, 4], [5, 6, 7, 8] ]

Ad= Matrix.dense(A)

or from a ﬂattened representation:

A= [ 1, 2, 3, 4, 5, 6, 7, 8 ]

Af= Matrix.dense(2, 4, A)

Sparse matrices are constructed with a variant of the static factory method Matrix.sparse . This is

both speed- and memory-eﬃcient when the matrix has few nonzero entries. A matrix 𝐴 in sparse format

is given by a list of triples (𝑖, 𝑗, 𝑣), each deﬁning one entry: 𝐴

𝑖,𝑗

= 𝑣. The order does not matter. The

entries not in the list are assumed to be 0. For example, take the matrix

𝐴 =



1.0 0.0 0.0 2.0

0.0 3.0 0.0 4.0



Assuming we number rows and columns from 0, the corresponding list of triplets is:

𝐴 = {(0, 0, 1.0), (0, 3, 2.0), (1, 1, 3.0), (1, 3, 4.0)}

The Fusion deﬁnition would be:

rows = [ 0, 0, 1, 1 ]

cols = [ 0, 3, 1, 3 ]

values= [ 1.0, 2.0, 3.0, 4.0 ]

m = Matrix.sparse(len(rows), len(cols), rows, cols, values)

The Matrix class provides more standard constructions such as the identity matrix, a constant value

matrix, block diagonal matrices etc.

6.6 Parameters

A parameter (Parameter ) is a placeholder for a constant whose value should be speciﬁed before the model

is optimized. Parameters can have arbitrary shapes, just like variables, and can be used in any place

where using a constant, array or matrix of the same shape would be suitable. That means parameters

behave like expressions under additive operations and stacking, and can additionally be used in some

multiplicative operations where the result is aﬃne in the optimization variables.

For example, we can create a parametrized constraint

𝑝

𝑇

𝑥 + 𝑞 ≤ 0,

where 𝑥 ∈ R

, as follows:

x = M.variable('x', 4) # Variable

p = M.parameter('p', 4) # Parameter of shape [ 4 ]

q = M.parameter() # Scalar parameter

M.constraint(Expr.add(Expr.dot(p, x), q), Domain.lessThan(0.0))

Later in the code we can initialize the parameters with actual values. For example

p.setValue([1,2,3,4])

q.setValue(5)

will make the previously deﬁned constraint evaluate to

𝑥

+ 2𝑥

+ 3𝑥

+ 4𝑥

+ 5 ≤ 0.

The values of parameters can be changed between optimizations. Therefore one parametrized model

with ﬁxed structure can be used to solve many instances of the same optimization problem with varying

input data.

6.7 Stacking and views

Fusion provides a way to construct logical views of parts of existing expressions or combinations of

existing expressions. They are still represented by objects of type Variable or Expression that refer

to the original ones. This can be useful in some scenarios:

• retrieving only the values of a few variables, and ignoring the remaining auxiliary ones,

• stacking vectors or matrices to perform various matrix operations,

• bundling a number of similar constraints into one; see Sec. 6.8,

• adding constraints between parts of the same variable, etc.

All these operations do not require new variables or expressions, but just lightweight logical views. In

what follows we will concentrate on expressions; the same techniques are available for variables. These

techniques will be familiar to the users of numerical tools such as Matlab or NumPy.

剩余360页未读，继续阅读

Quant0xff

粉丝: 1w+
资源: 459

MOSEK Fusion API for Python: 数学优化软件包指南

java基础GUI框架完成的贪吃蛇小游戏.zip

安卓期末大作业-Android跑步计数app期末大作业源码（高分项目）

C#毕业设计-基于ASP.NET的教师公寓管理系统源码.zip

stress-plan 是使用golang语言编写的轻量级压测工具，有着易用，从业务场景出发的压测功能 .zip

基于java的实验室考勤管理系统设计与实现.docx

基于.net的网络爬虫程序详细文档+资料齐全.zip

基于java的毕业生就业状况管理系统设计与实现.docx

mumu模拟器12电脑

07_Mapeo de severidad con Python y Sentinel-2.ipynb

深入解析分布式遗传算法及其Python实现

最新资源