RobustConvexOptimization

RobustConvexOptimization[f,ForAll[pars,pcons,vcons],vars]

パラメータ的な制約 pcons を満足するパラメータ pars の可能なすべての値について制約 vcons を満足する vars についての f の最小値を与える vars の値を求める．

RobustConvexOptimization[…,"prop"]

解のどの特性"prop"を返すかを指定する．

詳細とオプション

ロバスト最適化は最悪な場合の最適化としても知られている．
ロバスト最適化は，一般に，パラメータ制約があるパラメータによって表される不確かさのもとで最適化問題を解く際に使われる．
ロバスト最適化は，与えられた最適条件には可能なすべてのパラメータ値で達することができるという意味で，最も保守的な解を与える．
ロバスト最適化は，以下の問題を解くロバストなミニマイザを求める．
最小化

ただし
ロバストミニマイザは，パラメータ集合内のすべてのについてを満足する．
ロバスト最小値は，パラメータ集合内のすべてのについてを満足する．
pcons または vcons には，線形等式制約またはが含まれるかもしれない．
RobustConvexOptimization[f,cons,vars,pars]を使うこともできる．制約条件 cons は純粋にパラメータ的な制約条件とパラメータに依存する変数の制約条件に自動的に分離される．この形式はParametricConvexOptimizationと互換である．
ロバスト最適化問題は，可解のあるいは凸最適化で近似可能な問題の型にはめられる場合は扱いやすいと考えられる．扱いやすさは変数制約のタイプとパラメータ制約のタイプの組合せに依存する．
次の変数制約とパラメータ制約の組合せが扱いやすいと考えられる．
変数制約パラメータ制約

$TemplateBox[{{{{a, (, {theta, _, l}, )}, ., x}, +, {b, (, {theta, _, l}, )}}}, Norm]<=c(theta_r).x+d(theta_r)$

$a_0(theta)+a_1(theta) x_1+...+a_k(theta) x_k>=_(TemplateBox[{n}, SemidefiniteConeList])0$
一般に，変数制約はの形の円錐制約に変換される．ただし，は，"NonNegativeCone"，"NormCone"，"SemidefiniteCone"のいずれかであり，とのパラメータに対する依存関係はアフィンでなければならない．
目的関数がパラメータに依存する，あるいは非線形である場合は，追加的な変数が導入され，エピグラフ変換によって，問題が目的変数と追加的な制約条件を持つようになる．
変数指定とパラメータ指定の vars と pars は，それぞれ，以下のいずれかの形で変数とパラメータを与える要素のリストでなければならない．

	v	次元が推測される変数か名前がのスカラーパラメータ
	v∈Reals	実数のスカラー変数
	v∈Integers	整数のスカラー変数
	v∈Complexes	複素数のスカラー変数
	v∈ℛ	幾何学領域に制限されるベクトル変数
	v∈Vectors[n,dom]	，あるいは $TemplateBox[{}, Complexes]^n$ のベクトル変数
	v∈Matrices[{m,n},dom]	，あるいは $TemplateBox[{}, Complexes]^(m x n)$ の行列変数

使用可能な解の特性"prop"には以下がある．

	"PrimalMinimizer"		を最小化する変数値のリスト
	"PrimalMinimizerRules"		を最小化する変数 vars={v₁,…}の値
	"PrimalMinimizerVector"		を最小化するベクトル
	"PrimalMinimumValue"		最小値
	{"prop₁","prop₂",…}		いくつかの解の特性

次は，使用可能なオプションである．

MaxIterations	Automatic	使用する最大反復数
Method	Automatic	使用するメソッド
PerformanceGoal	$PerformanceGoal	最適化するパフォーマンスの局面
Tolerance	Automatic	内部比較の許容度

オプションMethodmethod を使って使用するメソッドが指定できる．以下は使用可能なメソッドである．

	Automatic	メソッドを自動的に選択する
	"CuttingSet"	CuttingSet法を使う
	"PolyhedralApproximation"	線形制約集合がある近似"NormCone"制約
	"SCS"	SCS（錐ソルバの分割）ライブラリ
	"CSDP"	CSDP（COIN半定値計画）ライブラリ
	"DSDP"	DSDP（半定値計画）ライブラリ

いくつかの扱いにくいロバストな最適化問題も，ほぼCuttingSet法で解くことができる．

例題

すべて開くすべて閉じる

例 (2)

制約条件に従うについてのロバストミニマイザを求める：

Wolfram Language code:

mrule = RobustConvexOptimization[x + y, Subscript[∀, {α, β}, -1 ≤ α ≤ 1 && 0 ≤ β ≤ 1](10 x ≥ α && y ≥ β), {x, y}]

ロバストミニマイザはのすべてのについて制約条件を満足する：

Wolfram Language code: Outer[Function[{α, β}, (10 x ≥ α && y ≥ β)] /. mrule, {-1, 1}, {0, 1}]

変数の制約条件に従うについてのロバストミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x, ForAll[{α}, α∈Interval[{-(1/2), (1/2)}], Inactive[Norm][{x + α, y}] ≤ 1], {x, y}]

ロバストミニマイザはすべての α∈[-.5,.5]についての制約条件集合の共通（緑）の部分である：

Wolfram Language code:

regions = (Norm[{x + #, y}] ≤ 1)& /@ Range[-.5, .5, .25];
RegionPlot[{regions, And@@regions}, ...]

スコープ (29)

基本的な用法 (15)

のとき，すべてのについて，についてのに従うロバストなミニマイザを求める：

Wolfram Language code: RobustConvexOptimization[x + y, ForAll[{θ}, -1 ≤ θ ≤ 1, {x + 2y ≥ 3 + θ, x ≥ -1}], {x, y}]

区間内のすべてのについて，についてのに従うロバストなミニマイザを求める：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[θ, θ∈Interval[{-1, 1}], 
	{x + 2y ≥ 3 + θ, x ≥ -1}], {x, y}]

となるようなすべてのについて，に従うについてのロバストなミニマイザを求める：

Wolfram Language code:

RobustConvexOptimization[x - y, ForAll[θ, -1 ≤ θ ≤ 1, 
	{x + 2y + z ≤ 1 + θ, x - 2z == 1, 2x - y ≥ 1 + θ}], {x, y, z}]

のとき，すべてのについてに従うについてのロバストなミニマイザを求める：

Wolfram Language code:

RobustConvexOptimization[α x + β y, ForAll[{α, β}, {0 ≤ α ≤ 1, 0 ≤ β ≤ 1}, {x + 2y ≥ 3 + α, x ≥ β}], {x, y}]

明示的なForAllなしで代替構文を使う：

Wolfram Language code: RobustConvexOptimization[α x + β y, {x + 2y ≥ 3 + α, x ≥ β, 0 ≤ α ≤ 1, 0 ≤ β ≤ 1}, {x, y}, {α, β}]

この構文をParametricConvexOptimizationで直接使っての特定の値を試してみる：

Wolfram Language code:

pfun = ParametricConvexOptimization[α x + β y, {x + 2y ≥ 3 + α, x ≥ β, 0 ≤ α ≤ 1, 0 ≤ β ≤ 1}, {x, y}, {α, β}]

Wolfram Language code: {pfun[1, 1], pfun[0, 0]}

VectorLessEqualを使っていくつかのLessEqual不等式制約を一度に表す：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[{α, β}, Inactive[Norm][{α, β}] ≤ 1, 
	VectorLessEqual[{{x - 2 y, -x + y}, {3 + α, 2 + β}}]], {x, y}]

v<= を使ってコンパクトな形でベクトル不等式を入力する：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[{α, β}, Inactive[Norm][{α, β}] ≤ 1, 
	{x - 2 y, -x + y}{3 + α, 2 + β}], {x, y}]

スカラー不等式を使った同等の形：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[{α, β}, Inactive[Norm][{α, β}] ≤ 1, 
	{x - 2y ≤ 3 + α, -x + y ≤ 2 + β}], {x, y}]

VectorGreaterEqualを使っていくつかのGreaterEqual不等式制約を一度に表す：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[{α, β}, 
	VectorGreaterEqual[{{-α - β, α, β}, {-1, 0, 0}}], 
	VectorGreaterEqual[{{x + 2y, x}, {3 + α, -1 + β}}]], {x, y}]

v>= を使ってベクトル不等式をコンパクトな形で入力する：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[{α, β}, {-α - β, α, β}{-1, 0, 0}, 
	{x + 2 y, x}{3 + α, -1 + β}], {x, y}]

スカラー不等式とベクトル不等式を組み合せて制約条件を指定する：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[θ, 1 ≤ θ ≤ 2, 
	{θ x + 2y ≥ 3, -1{x, y}{2, 1}}], {x, y}]

スカラー不等式を使った同等の形：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[θ, 1 ≤ θ ≤ 2, 
	{θ x + 2y ≥ 3, -1 ≤ x ≤ 2, -1 ≤ y ≤ 1}], {x, y}]

ベクトル変数とベクトル不等式を使って問題を指定する：

Wolfram Language code:

RobustConvexOptimization[Total[v], ForAll[θ, 1 ≤ θ ≤ 2, {{θ, 2}.v ≥ 3, 
	-1v1}], v]

であるすべてのについて，制約条件に従って関数を最小化する：

Wolfram Language code: {a, b} = {{{1, 1, 0}, {0, 1, 1}, {1, 1, 1}}, {2, 2, -1}};

Indexedを使ってベクトル変数の成分（例：）にアクセスする：

Wolfram Language code:

RobustConvexOptimization[Total[x], ForAll[{α, β}, Inactive[Norm][{α, β}] ≤ 1, 
	{a.xb + β, Indexed[x, 1] ≥ 1 + α}], x]

制約条件のパラメータ方程式を使って目的関数と制約条件の係数を指定する：

Wolfram Language code:

constantEquations = {c == {3, 4}, a1 == {1, -2}, a2 == {-1, 1}};
constraints = {a1.{x, y} ≤ 3 + α, a2.{x, y} ≤ 2 + β};

Wolfram Language code:

RobustConvexOptimization[c.{x, y}, ForAll[{α, β}, Inactive[Norm][{α, β}] ≤ 1, 
	{constantEquations, constraints}], {x, y}]

であるすべてのについて，制約条件に従って関数を最小にする：

Wolfram Language code: constantEquations = {a == {{1, 2}, {1, 0}}, b == {3, -1}};

Wolfram Language code:

RobustConvexOptimization[Total[x] + Total[y], ForAll[θ, -1 ≤ θ ≤ 1, 
	{constantEquations, a.xb, y2 + θ}], {x, y}]

必要なときは，Vectors[n,Reals]を使ってベクトル変数の次元を指定する：

Wolfram Language code:

RobustConvexOptimization[Total[x] + Total[y], ForAll[θ, -1 ≤ θ ≤ 1, 
	{constantEquations, a.xb, y2 + θ}], {x, y∈Vectors[3, Reals]}]

NonNegativeReals ()を使って非負の制約条件を指定する：

Wolfram Language code:

RobustConvexOptimization[Total[v], ForAll[θ, -0.1 ≤ θ ≤ 0.1, {1, 2}.v ≥ 3 + θ], v∈Vectors[2, NonNegativeReals]]

ベクトル不等式を使った同等の形：

Wolfram Language code:

RobustConvexOptimization[Total[v], ForAll[θ, -0.1 ≤ θ ≤ 0.1, 
	{{1, 2}.v ≥ 3 + θ, v0}], v]

NonPositiveReals ()を使って非正の制約条件を指定する：

Wolfram Language code: RobustConvexOptimization[-Total[v], ForAll[θ, -1 ≤ θ ≤ 1, {1, 2}.v-3 + θ], v∈Vectors[2, NonPositiveReals]]

Intervalを使って境界を指定する：

Wolfram Language code:

RobustConvexOptimization[-Total[v], ForAll[θ, θ∈Interval[{-1, 1}], 
	{1, 2}.v-3 + θ], v∈Vectors[2, NonPositiveReals]]

パラメータがグループ化され変数に割り当てられたときに，Evaluateを使ってForAllの第1引数が確実に評価されるようにする：

Wolfram Language code:

parameters = {α, β};
parameterConstraints = {-α - β ≥ -1, α ≥ 0, β ≥ 0};
constraints = {x + 2y ≥ 3 + α, x ≥ -1 + β};

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[Evaluate[parameters], 
	parameterConstraints, constraints], {x, y}]

線形変数制約 (5)

区間[0,2]内のすべてのについて，に従うについてのロバストなミニマイザを求める：

Wolfram Language code: RobustConvexOptimization[x, ForAll[θ, θ∈Interval[{0, 2}], x ≥ θ], x]

[0,2]内のすべてのについての制約条件とは，数学的にはを意味する．従って，この問題は以下と等しい：

Wolfram Language code: LinearOptimization[x, {x ≥ 2.}, x]

区間で制限されるすべてのについて，変数の制約条件に従ってについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x + y, ForAll[{α, β}, 
	{α∈Interval[{-.1, .1}], β∈Interval[{0, 1}]}, {x ≥ α, y ≥ β}], {x, y}]

の極値に設定されたミニマイザと変数制約を可視化する．緑で示されているパラメータの可能なすべての値に対して実行可能であるの集合は，パラメトリック実行可能領域の交点である：

Wolfram Language code: RegionPlot[{x ≥ -0.1 && y ≥ 0.1, x ≥ 0.1 && y ≥ 0, x ≥ -0.1 && y ≥ 1, x ≥ 0.1 && y ≥ 1}, ...]

区間に制約されるすべてのについて，変数制約条件に従うについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x, ForAll[{α, β}, {α∈Interval[{-.1, .1}], 
	β∈Interval[{0, 1}]}, {x + y ≥ α, x - y ≥ β}], {x, y}]

ミニマイザ，パラメータの極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

RegionPlot[{x + y ≥ -0.1 && x - y ≥ 0.1, x + y ≥ 0.1 && x - y ≥ 0, x + y ≥ -0.1  && x - y ≥ 1, x + y ≥ 0.1 && x - y ≥ 1}, ...]

であるすべてのについて，変数制約に従うについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x + y, ForAll[{α, β}, {Inactive[Norm][{α, β}] ≤ 1, 
	0 ≤ β ≤ 1}, {x ≥ α, y ≥ β, -x + y ≥ 0.1}], {x, y}]

ミニマイザ，パラメータの極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

region[α_, β_] := x ≥ α && y ≥ β && y - x ≥ 0.1;
RegionPlot[{region[-1, 0], region[1, 0], region[0, -1], region[0, 1], 
	y - x ≥ 0.1 && x ≥ 1}, ...]

であるすべてのについて，変数制約に従うについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x + y, ForAll[{α, β, δ}, {1 ≤ α ≤ 2, 
	0 ≤ β ≤ 1, δ ≥ -3 / 2, (⁠|   |   |
| - | - |
| α | δ |
| δ | β |⁠)Underscript[, {"SemidefiniteCone", 2}]0}, {x ≥ α, y ≥ β, x - y ≤ δ}], {x, y}]

パラメータの極値について，行列が半正定値になるようなの範囲を求める：

Wolfram Language code: ListPlot[Table[...], ...]

を変化させて生成された領域の共通部分で形成されたミニマイザと実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

region[α_, β_, δ_] := x ≥ α && y ≥ β && x - y ≤ δ;
RegionPlot[{region[1, 0, 3 / 2], region[2, 0, 3 / 2], region[1, 1, 3 / 2], region[2, 1, 3 / 2], region[1, 0, -3 / 2], region[2, 0, -3 / 2], region[1, 1, -3 / 2], region[2, 1, -3 / 2], x - y ≤ -(3/2) && x ≥ 2}, ...]

NormCone変数制約 (7)

であるすべてのについての変数制約上のについてのロバストミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x, ForAll[θ, θ∈Interval[{-0.2, 0.2}], 
	Inactive[Norm][{(1 + θ)x, y}] ≤ 1], {x, y}]

の極値に設定されたミニマイザと変数制約を可視化する．パラメータの可能なすべての値に対して実行可能なの集合は，全実行可能領域の共通部分（緑色で表示）である：

Wolfram Language code: RegionPlot[{Norm[{0.8x, y}] ≤ 1, Norm[{1.2x, y}] ≤ 1}, {x, -1.5, 1.5}, {y, -1.5, 1.5}, ...]

であるすべてのについての変数制約上のについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[y, ForAll[{α, β}, {-0.3 ≤ α ≤ 0.3, 
	-0.2 ≤ β ≤ 0.2}, Inactive[Norm][{(1 + α)x + β, y}] ≤ 1], {x, y}]

ミニマイザ，パラメータの極値に設定された変数制約，実行可能領域（緑色で表示）を可視化する：

Wolfram Language code:

reg[α_, β_] := Norm[{(1 + α) x + β, y}] ≤ 1;
RegionPlot[{reg[-.3, -.2], reg[-.3, .2], reg[.3, -.2], reg[.3, .2], reg[.3, .2] && reg[.3, -.2]}, ...]

であるすべてのについての変数制約上のについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x, ForAll[θ, -0.2 ≤ θ ≤ 0.2, 
	{Inactive[Norm][{(1 + θ)x, y}] ≤ 2, x + y ≥ -1, y ≥ 0}], {x, y}]

ミニマイザ，の極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

region[α_] := Norm[{(1 + α)x, y}] ≤ 2 && x + y ≥ -1 && y ≥ 0;
RegionPlot[{region[-0.2], region[0.2]}, ...]

であるすべてのについての変数制約上のについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[y, ForAll[{α, β}, {-0.2 ≤ α ≤ 0.2, 
	-0.1 ≤ β ≤ 0.1}, Inactive[Norm][{x + α, y}] ≤ 1 + β], {x, y}]

ミニマイザ，の極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

region[α_, β_] := Norm[{x + α, y}] ≤ 1 + β;
RegionPlot[{region[-0.2, -0.1], region[-0.2, 0.1], region[0.2, -0.1], region[0.2, 0.1], region[-0.2, -0.1] && region[0.2, -0.1]}, ...]

であるすべてのについての変数制約上のについてのロバストなミニマイザを求める：

Wolfram Language code:

RobustConvexOptimization[y, ForAll[{α, β}, {-0.2 ≤ α ≤ 0.2, 
	Inactive[Norm][{β}] ≤ 0.25}, Inactive[Norm][{x + α, y}] ≤ 1 + β], 
	{x, y}]

であるすべてのについての変数制約上のについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x - y, ForAll[{α, β}, Inactive[Norm][{α, β}] ≤ 0.4, 
	Inactive[Norm][{α + x, β + y}] ≤ 1], {x, y}]

ミニマイザ，の極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

region[α_, β_] := Norm[{x + α, y + β}] ≤ 1;
extremeRegions = {region[-0.4, 0], region[0.4, 0], region[0, -0.4], region[0, 0.4]};
RegionPlot[Evaluate[Append[extremeRegions, And@@extremeRegions]], ...]

であるすべてのについての変数制約上のについてのロバストなミニマイザを求める：

Wolfram Language code:

res = RobustConvexOptimization[x, ForAll[{α, β, δ}, 
	{Inactive[Norm][{α, β}] ≤ 0.5, 1 ≤ δ ≤ 2}, {Inactive[Norm][{α + x, β + y}] ≤ δ + x, x + y ≥ -1}], {x, y}]

ミニマイザ，の極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

extremeRegions = Table[...];
RegionPlot[Evaluate[Append[extremeRegions, And@@extremeRegions]], ...]

SemidefiniteCone変数制約 (2)

であるすべてのについての変数制約に従うについてのロバストな近似ミニマイザを求める：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[θ, θ∈Interval[{0, 2}], 
	VectorGreaterEqual[{{{x, 1 + θ}, {1 + θ, y}}, 0}, {"SemidefiniteCone", 2}]], {x, y}]

ミニマイザ，パラメータの極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

region[α_] := VectorGreaterEqual[{{{x, 1 + α}, {1 + α, y}}, 0}, {"SemidefiniteCone", 2}];
RegionPlot[{region[0], region[2]}, ...]

であるすべてのについての変数制約に従うについてのロバストな近似ミニマイザを求める：

Wolfram Language code:

RobustConvexOptimization[2x + 3y, ForAll[{α, β}, Inactive[Norm][{α, β}] ≤ 1, 
	VectorGreaterEqual[{{{1 + α + x, 1 + β}, {1 + β, 1 + α + y}}, 0}, {"SemidefiniteCone", 2}]], {x, y}]

ミニマイザ，パラメータの極値についての変数制約集合，実行可能領域（緑で表示）を可視化する：

Wolfram Language code:

region[α_, β_] := VectorGreaterEqual[{{{1 + α + x, 1 + β}, {1 + β, 1 + α + y}}, 0}, {"SemidefiniteCone", 2}];
extremeRegions = {region[0, 1], region[1, 0], region[0, -1], region[-1, 0]};
RegionPlot[Evaluate[Append[extremeRegions, And@@extremeRegions]], ...]

オプション (3)

Method (2)

Method"CuttingSet"を使ってロバストな対応部分が扱いにくい問題を解く：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[{α, β}, {1 ≤ α ≤ 3, 
	0.9 ≤ α + 5β ≤ 3.1}, {Inactive[Norm][{-6 + x, -4 + y}] ≤ 1 + 0.001 α, (⁠|               |               |
| ------------- | ------------- |
| 1 + (1 + β) x | 1 + α         |
| 1 + α         | 1 + (1 + β) y |⁠)Underscript[, {"SemidefiniteCone", 2}]0}], {x, y}];

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[{α, β}, {1 ≤ α ≤ 3, 
	0.9 ≤ α + 5β ≤ 3.1}, {Inactive[Norm][{-6 + x, -4 + y}] ≤ 1 + 0.001 α, (⁠|               |               |
| ------------- | ------------- |
| 1 + (1 + β) x | 1 + α         |
| 1 + α         | 1 + (1 + β) y |⁠)Underscript[, {"SemidefiniteCone", 2}]0}], {x, y}, Method -> "CuttingSet"]

パラメータの2つの極値についてのミニマイザと変数制約集合を（緑で示された）実行可能領域と一緒に可視化する．

Wolfram Language code:

fun[α_, β_] = VectorGreaterEqual[{{{1 + (1 + β) x, 1 + α}, {1 + α, 1 + (1 + β) y}}, 0}, {"SemidefiniteCone", 2}];
RegionPlot[{fun[1, -0.1 / 5], fun[1, 2.1 / 5], fun[3, -2.1 / 5], fun[3, 0.1 / 5], Norm[{x - 6, y - 4}] ≤ 1, Norm[{x - 6, y - 4}] ≤ 1 && fun[3, -2.1 / 5]}, ...]

Method"PolyhedralApproximation"を使って"NormCone"制約を線形化する．こうすることで，他の方法では扱いにくいロバストな対応部分を使った近似解の問題が可能になる：

Wolfram Language code:

RobustConvexOptimization[x, ForAll[{α, β}, {-0.2 ≤ α + β ≤ 0.2, 
	-0.1 ≤ α ≤ 0.1}, Inactive[Norm][{x + α, y + β}] ≤ 1], {x, y}]

Wolfram Language code:

res = RobustConvexOptimization[x, ForAll[{α, β}, {-0.2 ≤ α + β ≤ 0.2, 
	-0.1 ≤ α ≤ 0.1}, Inactive[Norm][{x + α, y + β}] ≤ 1], {x, y}, Method -> "PolyhedralApproximation"]

パラメータの2つの極値について，ミニマイザと変数制約集合を可視化する：

Wolfram Language code:

region[α_, β_] := Norm[{x + α, y + β}] ≤ 1;
extremeRegions = {region[-0.1, -0.1], region[-0.1, 0.3], region[0.1, -0.3], region[0.1, 0.1]};
RegionPlot[Evaluate[Append[extremeRegions, And@@extremeRegions]], ..., Epilog -> {PointSize[0.02], Point[{x, y} /. res]}]

Tolerance (1)

Toleranceの設定を小さくするとより厳密な結果が与えられる：

Wolfram Language code:

{obj, varConstraints, vars} = {x, Inactive[Norm][{α + x, β + y}] ≤ 1, {x, y}};
{parConstraints, parameters} = {{-0.1 ≤ α ≤ 0.1, -0.2 ≤ β ≤ 0.2, 
	Inactive[Norm][{α, β}] ≤ 0.1}, {α, β}};

この問題に対する厳密値はの設定で求まる：

Wolfram Language code: exact = ConicOptimization[obj, {varConstraints, α == -0.1, β == 0}, vars, "PrimalMinimizerVector"]

Toleranceの設定値を変えて誤差を計算する：

Wolfram Language code:

err = Table[{tol, Norm[RobustConvexOptimization[obj, 
	ForAll[Evaluate[parameters], parConstraints, varConstraints], vars, "PrimalMinimizerVector", Method -> "PolyhedralApproximation", Tolerance -> tol, MaxIterations -> 100000] - exact]}, {tol, 10 ^ -Range[4., 9]}]

許容値に対する最小値の誤差の変化を可視化する：

Wolfram Language code: ListLogLogPlot[err, PlotRange -> All, Joined -> True, PlotMarkers -> Automatic]

アプリケーション (14)

幾何学問題 (2)

サブサークルの集合を囲い込む最小な円の中心と半径を求める：

Wolfram Language code:

SeedRandom[1234];
n = 20;
centers = RandomReal[{-1, 1}, {n, 2}];
radii = RandomReal[{.1, .3}, n];

サブサークルは，不確かさの円板の中心である点によって表される：

Wolfram Language code:

Δ = Table[Indexed[δ, i], {i, n}];
uncertainPoints = MapThread[Inactive[Plus], {centers, Δ}];
uncertaintyConstraints = MapThread[Norm[#1] ≤ #2&, {Δ, radii}];

目的は，制約条件に従って半径を最小化することである：

Wolfram Language code: constraints = Table[Norm[Inactive[Plus][pi, -c]] ≤ r, {pi, uncertainPoints}];

円板の中心と半径は次のようになる：

Wolfram Language code:

res = RobustConvexOptimization[r, 
	ForAll[δ, {Element[δ, Matrices[{n, 2}, Reals]], uncertaintyConstraints}, constraints], 
	{r, c∈Vectors[2, Reals]}]

結果をプロットする：

Wolfram Language code:

Graphics[{Circle[c, r] /. res, {Red, PointSize[0.02], Point[centers]}, MapThread[{Opacity[0.2], Blue, Disk[##]}&, {centers, radii}]}]

不確かさが楕円でモデル化されるときの，半径がで中心がとの2つの円板の最短距離を求める：

Wolfram Language code:

center1 = {α, β};
center2 = {2.5 + α, 1.5 + β};

とを円板1と円板2に関連付けられた点とする．目的はに従ってを最小化することである：

Wolfram Language code:

res = RobustConvexOptimization[Inactive[Norm][Subscript[p, 1] - Subscript[p, 2]], ForAll[{α, β, δ}, 
	δ∈Interval[{-.4, .4}], {Inactive[Norm][Subscript[p, 1] + {α, β}] ≤ 1 + δ, 
	Inactive[Norm][Subscript[p, 2] + {-2.5 - α, -1.5 - β}] ≤ 1 + δ, Inactive[Norm][{α, β}] ≤ 0.3}], {Subscript[p, 1]∈Vectors[2, Reals], Subscript[p, 2]∈Vectors[2, Reals]}]

中心と半径が不確かな2つの円板の最短距離は以下のようになる：

Wolfram Language code: Norm[Subscript[p, 1] - Subscript[p, 2]] /. res

2つの点の位置を不確かな円板のいくつかの極端な例と一緒に可視化する：

Wolfram Language code:

SeedRandom[123];
offset = Block[...];
radius = RandomReal[{-0.4, 0.4}, Length[offset]];
extreme = {{{-0.3, 0}, 1 - 0.4}, {{0, -0.3}, 1 - 0.4}, {{-0.3, -0.3} / Sqrt[2], 1 - 0.4}};
Graphics[...]

データフィッティング問題 (3)

区間の不確かさに従って，応答があるデータのロバストな線形フィットを求める：

Wolfram Language code:

{input, response} = {...};
n = Length[input];
dataPlot = ListPlot[Transpose[{input, response + Interval[{-.25, .25}]}]]

目的は，区間の不確かさに従って入出力間の誤差を最小にすることである：

Wolfram Language code: objective = Inactive[Norm][b + m input + -response + -θ];

ロバストなフィット y=m x+b の傾き m と切片 b を求める：

Wolfram Language code: robustFit = RobustConvexOptimization[objective, ForAll[θ, {θ∈Vectors[n, Reals], -0.25θ0.25}], {m, b}]

データの単純な最小二乗フィットを計算する：

Wolfram Language code: simpleFit = ConvexOptimization [objective, {θ == 0}, {m, b}]

不確かさの100の可能な実現のためのフィットモデルを求める：

Wolfram Language code:

pfun = ParametricConvexOptimization [objective, {}, {m, b}, {θ∈Vectors[n, Reals]}];
models = Table[pfun[RandomReal[{-.25, .25}, n]], {100}];

ロバストフィット（マゼンタ），単純フィット（緑），データで，フィットモデルの包絡線を表示する：

Wolfram Language code:

Show[Plot[{m x + b /. robustFit, m x + b /. simpleFit, Min[m x + b /. models], Max[m x + b /. models]}, {x, 0, 1}, Filling -> {3 -> {4}}, PlotStyle -> {Directive[Thickness[.01], Magenta], 
	Green, Automatic, Automatic}], dataPlot]

出力に区間の不確かさが含まれる離散データに三次曲線をフィットする：

Wolfram Language code:

{input, output} = Block[{n = 30, input, output}, SeedRandom[12345];input = Range[0., 1., (1/n)];output = Sin[3 input^3 / 2] + RandomReal[{-0.1, 0.1}, n + 1];{input, output}];
dataplot = ListPlot[Transpose[{input, Interval[{-0.1, 0.1}] + output}]]

DesignMatrixを使って入力行列を構築する：

Wolfram Language code:

basis = {1, x, x^2, x^3};
mat = DesignMatrix[Transpose[{input, output}], basis, x];

目的は区間の不確かさに従って入出力間の誤差を最小にすることである：

Wolfram Language code: objective = Inactive[Norm][mat.coeffs + -(output + θ)];

各基底に関連付けられた係数を求める：

Wolfram Language code:

res = RobustConvexOptimization[objective, ForAll[θ, {-0.1θ0.1, 
	θ∈Vectors[Length[output], Reals]}], coeffs]

不確かさの可能な100の実現についてのフィットモデルを求める：

Wolfram Language code:

n = Length[output];
pfun = ParametricConvexOptimization [objective, {}, coeffs, θ∈Vectors[n, Reals]];
models = Table[pfun[RandomReal[{-.1, .1}, n]], {200}];

フィットモデルの包絡線を，ロバストなフィット（緑）およびデータとともに表示する：

Wolfram Language code: Show[Plot[{(coeffs /. res).basis, Min[(coeffs /. models).basis], Max[(coeffs /. models).basis]}, ...], dataplot]

ロバストなフィット（緑）と平均モデル（赤）をノイズのない厳密解と比較する：

Wolfram Language code:

Plot[Evaluate[{(coeffs /. res).basis, 
	Mean[(coeffs /. models).basis]} - Sin[3x^3 / 2]], {x, 0, 1}, PlotStyle -> {Green, Red}, PlotRange -> All]

ロバストなフィットは平均モデルよりも誤差が大きくなる傾向がある：

Wolfram Language code:

Abs[NIntegrate[#, {x, 0, 1}]& /@ ({(coeffs /. res).basis, 
	Mean[(coeffs /. models).basis]} - Sin[3x^3 / 2])]

測定のインスタンス（入力）が不確かな範囲にある離散データに三次曲線をフィットする：

Wolfram Language code:

{input, output} = Block[...];
basis = {1, x, x^2, x^3};

入力行列で区間の不確かさに従って係数を求める：

Wolfram Language code:

mat = DesignMatrix[Transpose[{input, output}], basis, x];
res = RobustConvexOptimization[Inactive[Norm][(mat + θ).coeffs + -output], 
	ForAll[θ, {-0.1θ0.1, θ∈Matrices[Dimensions[mat], Reals]}], coeffs]

入力ノイズのランダムなインスタンスから生成された包絡線を使用して，ロバストなフィットを表示する：

Wolfram Language code:

curves = Block[...];
envelope = Plot[{Min[curves], Max[curves]}, {x, 0, 1}, Filling -> {1 -> {2}}];Show[envelope, Plot[(coeffs /. res).basis, {x, 0, 1}, PlotStyle -> Green]]

ロバストなフィット（緑）と平均モデル（赤）をノイズのない厳密解と比較する：

Wolfram Language code: Plot[Evaluate[{(coeffs /. res).basis, Mean[curves]} - Sin[3x^3 / 2]], {x, 0, 1}, PlotStyle -> {Green, Red}]

製造問題 (3)

2つの異なる原材料から活性剤を抽出する際の不確かさを考慮して利益を最大化するためにある会社が製造する2つの薬剤の最適な組合せを求める．医薬品の単位あたりの収益は以下の通りである：

Wolfram Language code: revenuePerUnit = {6200, 6900};

同社は1000kgの原材料しか保管できない：

Wolfram Language code: storageConstraint = Subscript[r, 1] + Subscript[r, 2] ≤ 1000;

2つの薬の製造には90から100時間の人的資源が必要である．同社の人的資源は2000時間分しかない：

Wolfram Language code: manPowerConstraint = 90Subscript[d, 1] + 100Subscript[d, 2] ≤ 2000;

2つの薬を製造するのに40から50時間の機械時間が必要である．同社の機械時間は800時間しかない：

Wolfram Language code: equipmentConstraint = 40Subscript[d, 1] + 50Subscript[d, 2] ≤ 800;

2つの薬を製造するための運用コストはそれぞれ700と800である．キログラムあたりの原材料費はそれぞれ100と199.9である：

Wolfram Language code:

operationalCost = 700Subscript[d, 1] + 800 Subscript[d, 2];
purchasingCost = 100Subscript[r, 1] + 199.9Subscript[r, 2];
totalCost = operationalCost + purchasingCost;

同社の総予算は$100,000である：

Wolfram Language code: budgetConstraint = totalCost ≤ 100000;

同社は数単位の薬を製造しなければならず，したがってある程度の原材料を購入しなければならない：

Wolfram Language code: productConstraint = {Subscript[d, 1] ≥ 0, Subscript[d, 2] ≥ 0, Subscript[r, 1] ≥ 0, Subscript[r, 2] ≥ 0};

2つの原材料から抽出される活性剤の量は，それぞれg/kgおよびg/kgの原材料である．2つの薬はそれぞれ0.5g /単位と0.6g /単位の活性剤を必要とする：

Wolfram Language code:

activeAgentConstraint = (0.01 + Subscript[θ, A])Subscript[r, 1] + (0.02 + Subscript[θ, B])Subscript[r, 2] ≥ 0.5Subscript[d, 1] + 0.6Subscript[d, 2];
activeAgentUncertainityConstraint = {-0.00005 ≤ Subscript[θ, A] ≤ 0.00005, 
	-0.0004 ≤ Subscript[θ, B] ≤ 0.0004};

目的は，購入コストと運用コストを最小限に抑えながら収益を最大化することである：

Wolfram Language code: objective = totalCost - revenuePerUnit.{Subscript[d, 1], Subscript[d, 2]};

薬品の最適な組合せは以下の通りである：

Wolfram Language code:

res = RobustConvexOptimization[objective, ForAll[{Subscript[θ, A], Subscript[θ, B]}, activeAgentUncertainityConstraint, {storageConstraint, 
	manPowerConstraint, equipmentConstraint, budgetConstraint, productConstraint, activeAgentConstraint}], {Subscript[d, 1], Subscript[d, 2], Subscript[r, 1], Subscript[r, 2]}]

不確かさを考慮した収益は以下のようになる：

Wolfram Language code: robustProfit = -objective /. res

この問題のパラメトリック関数を構築する：

Wolfram Language code:

pfun = ParametricConvexOptimization[objective, {storageConstraint, 
	manPowerConstraint, equipmentConstraint, budgetConstraint, productConstraint, activeAgentConstraint, activeAgentUncertainityConstraint}, {Subscript[d, 1], Subscript[d, 2], Subscript[r, 1], Subscript[r, 2]}, {Subscript[θ, A], Subscript[θ, B]}]

原材料に活性剤の変動がない場合は，2番目の原材料が優先される：

Wolfram Language code: nominalRes = pfun[0, 0]

不確かさを含まない収益は以下のようになる：

Wolfram Language code: nominalProfit = -objective /. nominalRes

不確かさを考慮すると収益が最大で6%減少する：

Wolfram Language code: (nominalProfit - robustProfit) / nominalProfit

ロバストな解は，原材料から抽出される活性剤の量が最も少ないという最悪のシナリオに対応する：

Wolfram Language code: pfun[-0.00005, -0.0004]

ロバストな解を使用する利点を確認するために，原材料と活性剤の不確かさをパラメータとして使ってパラメトリック関数を生成する：

Wolfram Language code:

pfun2 = ParametricConvexOptimization[objective, {
	manPowerConstraint, equipmentConstraint, budgetConstraint, activeAgentConstraint, activeAgentUncertainityConstraint, Subscript[d, 1] ≥ 0, Subscript[d, 2] ≥ 0}, {Subscript[d, 1], Subscript[d, 2]}, {Subscript[r, 1], Subscript[r, 2], Subscript[θ, A], Subscript[θ, B]}, "PrimalMinimumValue"];

名目上の結果，つまりを使用して原材料を購入した場合，原材料から抽出できる活性剤の量によっては，利益が21％減少する可能性がある：

Wolfram Language code: (nominalProfit - (-pfun2[0, 438.789, 0, -0.0004])) / nominalProfit

原材料がロバストな結果を使用して購入された場合，つまり，の場合，利益は最大6％減少する可能性がある：

Wolfram Language code: (nominalProfit - (-pfun2[877.732, 0, -0.00005, 0])) / nominalProfit

2番目の原材料から抽出できる活性剤の関数として利益をプロットする：

Wolfram Language code:

Plot[{nominalProfit, -pfun2[877.732, 0, -0.00005, 0], -pfun2[0, 438.789, 0, Subscript[θ, B]]}, {Subscript[θ, B], -0.0004, 0.0004}, ...]

製造入力に不確かさがある企業の利益を最大化する製造製品の組合せを求める．同社は3つの製品を製造している．理想的な条件下では，単位あたりの収益，単位あたりのコスト，最大容量は次の式で与えられる：

Wolfram Language code:

baseRevenuePerUnit = {90., 100., 70.};
baseCostPerUnit = {45., 40., 20.};
baseCapacity = {100, 40, 60};

各製品は4台の機械を使用して作られる．機械が各製品に費やす時間は次の通りである：

Wolfram Language code: TableForm[machineTime = {{20, 10, 10}, {12, 28, 16}, {15, 6, 5}, {10, 15, 0}}, Rule[...]]

市場の変動のために，製品の各単位によって生成される収益は5ドル減少する可能性がある：

Wolfram Language code:

revenuePerUnit = Inactive[Plus][baseRevenuePerUnit, -Subscript[θ, r]];
revenueUncertaintyConstraint = 0Subscript[θ, r]5;

機械のダウンタイムを考慮すると，製造能力は製品ごとに5ユニット減少する可能性がある：

Wolfram Language code:

capacity = Inactive[Plus][baseCapacity, -Subscript[θ, cap]];
capacityUncertaintyConstraint = 0Subscript[θ, cap]5;
capacityConstraint = 0xcapacity;

各機械は週に最大2400分実行できる．機械が稼働していない場合，稼働状態に戻るまでに最大120分かかる：

Wolfram Language code:

timeConstraint = machineTime.x2400 - Subscript[θ, time];
timeUncertaintyConstraint = 0Subscript[θ, time]120;

4台の機械のいずれかを修理するためのコストは，各製品のコストを1単位あたり5ドル増加させる：

Wolfram Language code:

costPerUnit = Inactive[Plus][baseCostPerUnit, Subscript[θ, cost]];
costUncertaintyConstraint = 0Subscript[θ, cost]5;

利益は収益からコストを引いたものに製品の単位数を掛けたものに等しくなる：

Wolfram Language code: profit = Inactive[Plus][revenuePerUnit, -costPerUnit].x;

すべての変数制約を収集する：

Wolfram Language code: variableConstraints = {capacityConstraint, timeConstraint};

すべてのパラメータ制約を収集する：

Wolfram Language code:

parameterConstraints = {revenueUncertaintyConstraint, capacityUncertaintyConstraint, timeUncertaintyConstraint, costUncertaintyConstraint};

すべてのパラメータ指定を収集する：

Wolfram Language code:

parameters = {Subscript[θ, r], Subscript[θ, cap], Subscript[θ, time], Subscript[θ, cost]};
parameterDomains = {Subscript[θ, r]∈Vectors[3, Reals], Subscript[θ, cap]∈Vectors[3, Reals], Subscript[θ, time]∈Vectors[4, Reals], Subscript[θ, cost]∈Vectors[3, Reals]};

目的は，収益を最大にすることである．最適な製品の組合せは以下で与えられる：

Wolfram Language code:

res = RobustConvexOptimization[-profit, ForAll[Evaluate[parameters], 
	{parameterDomains, parameterConstraints}, variableConstraints], x∈Vectors[3, Integers]]

さまざまなパラメータを変更するためのパラメトリック関数を作成する：

Wolfram Language code:

pfun = ParametricConvexOptimization[-profit, {variableConstraints, parameterConstraints}, x∈Vectors[3, Integers], parameterDomains, {"PrimalMinimumValue", "PrimalMinimizerRules"}]

最良のシナリオでは，収益の減少や機械のダウンタイムは発生せず，以下のようになる：

Wolfram Language code: pfun[{0, 0, 0}, {0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0}]

最悪のシナリオは，RobustConvexOptimizationによって得られた結果に対応する：

Wolfram Language code: pfun[{5, 5, 5}, {5, 5, 5}, {120, 120, 120, 120}, {5, 5, 5}]

価格と供給の変動に応じて3つの製品を販売する会社の利益を最大化する製造製品の組合せを求める．

単位あたりの価格変動を考慮した単位あたりの収益は以下の通りである：

Wolfram Language code:

baseRevenuePerUnit = {50., 40., 40.};
 revenuePerUnit = Inactive[Plus][baseRevenuePerUnit, -Subscript[θ, r]];
revenueUncertaintyConstraint = -5Subscript[θ, r]5;

この工場は100日しか稼働しない．理想的には，各単位の製造に2，4，5日かかるが，予期しない遅延により製造時間が1日長くなる可能性がある：

Wolfram Language code:

laborConstraint = Inactive[Plus][{2 , 4, 5}, Subscript[θ, delay]].x ≤ 100;
delayUncertaintyConstraint = 0Subscript[θ, delay]1;

各製品には金と錫が含まれている．各単位で使用可能な金と錫は，それぞれおよびである：

Wolfram Language code:

goldConstraint = {1, 1, 1}.x ≤ 30 + Subscript[θ, gold];
tinConstraint = {10, 5, 3}.x ≤ 200 + Subscript[θ, tin];
goldUncertaintyConstraint = -5 ≤ Subscript[θ, gold] ≤ 5;
tinUncertaintyConstraint = -10 ≤ Subscript[θ, tin] ≤ 10;

製品が製造された場合，会社は各製品のセットアップ費用を負担する：

Wolfram Language code: setupCost = {500, 500, 300};

セットアップ費用が比較的高いため，一部の製品を全く製造しないことが望ましい場合がある．を，製品が製造されている場合は，それ以外の場合はとなる決定変数とする．制限は他の制約よりものサイズを制限することなく，が0の場合はも0であることを保証する：

Wolfram Language code: decisionConstraints = {0w1, 0x1000w};

目的は収益を最大にすることである：

Wolfram Language code: profit = revenuePerUnit.x - setupCost.w;

すべての変数制約を収集する：

Wolfram Language code: variableConstraints = {laborConstraint, goldConstraint, tinConstraint, decisionConstraints};

パラメータ制約を収集する：

Wolfram Language code:

parameterConstraints = {revenueUncertaintyConstraint, delayUncertaintyConstraint, goldUncertaintyConstraint, tinUncertaintyConstraint};

パラメータ指定を収集する：

Wolfram Language code:

parameters = {Subscript[θ, r], Subscript[θ, delay], Subscript[θ, gold], Subscript[θ, tin]};
parameterDomains = {Subscript[θ, r]∈Vectors[3, Reals], Subscript[θ, delay]∈Vectors[3, Reals], Subscript[θ, gold]∈Reals, Subscript[θ, tin]∈Reals};

最適な組合せは以下で与えられる：

Wolfram Language code:

RobustConvexOptimization[-profit, ForAll[Evaluate[parameters], {parameterDomains, parameterConstraints}, variableConstraints], {x∈Vectors[3, Integers], w∈Vectors[3, Integers]}]

さまざまなパラメータを変えるためのパラメトリック関数を構築する：

Wolfram Language code:

pfun = ParametricConvexOptimization[-profit, {variableConstraints, 
	parameterConstraints}, {x∈Vectors[3, Integers], 
	w∈Vectors[3, Integers]}, parameterDomains]

結果は以下で与えられる最悪ケースのシナリオと一致する：

Wolfram Language code: pfun[{-5, -5, -5}, {1, 1, 1}, -5, -10]

構造最適化問題 (1)

バネの剛性と平衡長の両方が製造上の不確かさの影響を受ける各リンクの端に垂直荷重がかかった状態で，のバネリンクによって形成される吊り下げチェーンの形状を求める．目的はリンクの位置を求めることである：

重力による位置エネルギーはである．ただし，は両端の垂直荷重，は重力である：

Wolfram Language code:

n = 20;
gravityPE = m g Total[y];

伸縮によるバネリンクの張力による位置エネルギーはである．ここで，はバネリンクの伸縮，はバネの不確かな剛性であり，はバネの理想的な剛性である．を使用してエネルギーをに変換する：

Wolfram Language code: springPE = (1 + Subscript[θ, s])k u;

変換のために，追加的な制約条件を加えなければならない：

Wolfram Language code:

auxConstraint = Norm[t]^2 ≤ 2u;
energyConstraint = VectorGreaterEqual[{t, 0}];

リンクチェーンの端は(0,0)と(2,-1)に固定されている：

Wolfram Language code: endConditions = {Indexed[x, 1] == 0, Indexed[y, 1] == 0, Indexed[x, n + 1] == 2, Indexed[y, n + 1] == -1};

各リンクは制約条件を満足しなければならない．ただし，は不確かさに従う各バネの静止長である：

Wolfram Language code:

linkConditions = Table[Inactive[Norm][{Indexed[x, i] - Indexed[x, i + 1], 
	Indexed[y, i] - Indexed[y, i + 1]}] - (1 + Indexed[δ, i])Subscript[l, 0] ≤ Indexed[t, i], {i, 1, n}];

設計定数パラメータは以下の通りである：

Wolfram Language code: constants = {k -> 500, m -> 1, g -> 9.81, Subscript[l, 0] -> 0.25};

最終的な目的関数は，最小化する必要がある重力とバネの位置エネルギーの合計である：

Wolfram Language code: totalEnergy = (gravityPE + springPE) /. constants;

各バネリンクの端点を求める：

Wolfram Language code:

res = RobustConvexOptimization[totalEnergy, ForAll[{Subscript[θ, s], δ}, {Subscript[θ, s]∈Interval[{-0.01, 0.01}], δ∈Vectors[n, Reals], -0.01δ0.01}, {auxConstraint, endConditions, linkConditions} /. constants], {t∈Vectors[n, Reals], x∈Vectors[n + 1, Reals], y∈Vectors[n + 1, Reals], u}, MaxIterations -> 10 ^ 5]

結果のバネチェーンの形状を可視化する：

Wolfram Language code: ListLinePlot[Transpose[{x, y} /. res], PlotMarkers -> Automatic]

伸びはリンクチェーンの端のリンクで最大になる．伸びが最小なのはリンク12である：

Wolfram Language code: BarChart[Evaluate[t /. res], ChartLabels -> Range[n], ImageSize -> 300]

ポートフォリオの最適化 (2)

平均リターンに不確実性がある場合にリスクを最小限に抑えながらリターンを最大化するために，市場のボラティリティの影響を受ける可能性のある20の候補株から投資する6つの株の最適な組合せを見付ける．株式の期待収益値および株式間の共分散は次の通りである：

Wolfram Language code:

{μ, Σ} = Block[...];
n = Length[μ];

市場の変動のために各株式の平均収益値は不確実性の影響を受ける：

Wolfram Language code: meanUncertaintyConstraint = -4Subscript[θ, m]4;

を株式への総投資の割合とする．リターンはで与えられる：

Wolfram Language code: return = (μ + Subscript[θ, m]).w;

リスクはで与えられる：

Wolfram Language code: risk = Inactive[Norm][CholeskyDecomposition[Σ].w];

はならばその株を買うことになる決定ベクトルであるとすると，6つの株を選択しなければならない：

Wolfram Language code: decisionConstraints = {Total[x] == 6, 0x1};

投資の割合は0より大きく合計で1でなければならない：

Wolfram Language code: weightConstraints = {0wx, Total[w] == 1};

リスクを最小にしてリターンを最大にする株の最適な組合せを求める：

Wolfram Language code:

{pval, res} = RobustConvexOptimization[risk - return, ForAll[Subscript[θ, m], Subscript[θ, m]∈Vectors[n, Reals], {decisionConstraints, 
	weightConstraints, meanUncertaintyConstraint}], {w, x∈Vectors[n, Integers]}, {"PrimalMinimumValue", 
	"PrimalMinimizerRules"}]

最も安全な株の組合せは以下の通りである：

Wolfram Language code: stockPicks = Flatten[Position[x /. res, 1]]

それぞれの株に対する投資割合は以下の通りである：

Wolfram Language code: (w /. res)[[stockPicks]]

安全なリスクとリターンは以下の通りである：

Wolfram Language code: {safeRisk = Activate[risk /. res], safeReturn = safeRisk - pval}

さまざまなパラメータを変更するためのパラメトリック関数を作成する：

Wolfram Language code:

pfun = ParametricConvexOptimization[risk - return, {decisionConstraints, 
	weightConstraints}, {w, x∈Vectors[n, Integers]}, Subscript[θ, m]∈Vectors[n, Reals]]

最も安全で最適な株式の組合せは，不確実性のランダムなインスタンスを持つ最適な株式と比較して，最小のリスクとリターンを提供する：

Wolfram Language code:

optimalRiskReturns = Table[...];
ListPlot[{optimalRiskReturns, {{safeRisk, safeReturn}}}, ...]

平均リターンと共分散の両方に不確実性がある場合に，リスクを最小化しながらリターンを最大化するためのに6つの株に投資する資本の分布を見付ける．株の期待収益値および株間の共分散は次の通りである：

Wolfram Language code:

{μ, Σ} = Block[...];
n = Length[μ];

市場の変動のために，各株式のリターン値は不確実性の影響を受ける：

Wolfram Language code: meanUncertaintyConstraint = -4Subscript[θ, m]4;

を株式への総投資の割合とする．リターンはで与えられる：

Wolfram Language code: return = (μ + Subscript[θ, m]).w;;

共分散は有限のデータ集合から抽出され，不確実性の影響を受ける：

Wolfram Language code:

u = Inactive[Plus][CholeskyDecomposition[Σ], δ];
varianceUncertaintyConstraint = -0.1δ0.1;

リスクはで与えられる．はリスク回避パラメータである：

Wolfram Language code: risk = Inactive[Norm][u.w];

目的は，指定されたリスク回避パラメータのリスクを最小限に抑えながらリターンを最大にすることである：

Wolfram Language code: objective[α_ ? NumericQ] := -(return - α risk);

投資の割合は0より大きく合計で1でなければならない：

Wolfram Language code: weightConstraints = {w0, Total[w] == 1};

一連のリスク回避パラメータのリターンと対応するリスクを計算する：

Wolfram Language code:

riskAversionParameter = N@{1 / 100, 1 / 2, 1, 10, 100, 1000};
res = Table[{α, w} /. RobustConvexOptimization[objective[α], 
	ForAll[{Subscript[θ, m], δ}, {Subscript[θ, m]∈Vectors[n], δ∈Matrices[{n, n}]}, {weightConstraints, meanUncertaintyConstraint, 
	varianceUncertaintyConstraint}], w, Method -> "CSDP"], {α, riskAversionParameter}];

リスク回避パラメータを大きくすると，リスクを減らすための株式の分散に繋がる：

Wolfram Language code: Legended[BarChart[res[[All, -1]], ...], SwatchLegend[...]]

施設の場所問題 (1)

ある会社が新しい工場を開設したいと考えている．工場には5つの倉庫からの原材料が必要である．新しい工場と倉庫の間の，の間で変動する単位距離あたりの輸送コストは次の通りである：

Wolfram Language code:

costPerUnitDist = Inactive[Plus][{1000, 1500, 2000, 1000, 1500}, Subscript[θ, cost]];
costUncertaintyConstraint = -100Subscript[θ, cost]100;

を工場と倉庫の間の距離とする．目的はを最小化することである：

Wolfram Language code: totalCost = costPerUnitDist.d;

5つの倉庫は以下にある：

Wolfram Language code: pos = {{0, 0}, {1, 0}, {3 / 2, 1}, {-1 / 2, 1}, {1 / 2, 3 / 2}};

新たな工場はとなるような位置になければならない：

Wolfram Language code: constraints = Table[Norm[Inactive[Plus][pos[[i]], -Subscript[p, new]]] ≤ Indexed[d, i], {i, Length[pos]}];

新規工場と倉庫の間の最適な距離を求める：

Wolfram Language code:

res = RobustConvexOptimization[totalCost, ForAll[Subscript[θ, cost], Subscript[θ, cost]∈Vectors[5, Reals], {constraints, 
	costUncertaintyConstraint}], {d, Subscript[p, new]∈Vectors[2]}]

新規工場の場所は輸送コストが高い倉庫に近い：

Wolfram Language code: ListPlot[Thread[{pos}], Sequence[...], Epilog -> {Red, PointSize[0.03], Point[Subscript[p, new] /. res]}]

分類問題 (2)

2つの点集合とを分離する線分を求める．ただし，は区間の不確かさである：

Wolfram Language code: {set1, set2} = Block[...];

分離するために，集合1はを，集合2はを満足しなければならない：

Wolfram Language code: constraints = {Inactive[Plus][set1, α].a + b1, Inactive[Plus][set2, β].a + b-1};

目的はを最小化することである．これによってとの間の最大の厚さが得られる：

Wolfram Language code:

res = RobustConvexOptimization[Norm[a], ForAll[{α, β}, {α∈Matrices[Dimensions[set1], Reals], β∈Matrices[Dimensions[set2], Reals], 
	-0.05α0.05, -0.05β0.05}, constraints], {a, b}]

分離線は次の通りである：

Wolfram Language code: line = a.{x, y} + b /. res

分類器を各点のボックスの不確かさとともに可視化する：

Wolfram Language code:

Show[RegionPlot[line ≤ 0, {x, 0, 1}, {y, 0, 1}], Graphics[{EdgeForm[StandardGray], FaceForm[None], Rectangle[# - 0.05, # + 0.05]& /@ Join[set1, set2]}], ListPlot[{set1, set2}, PlotMarkers -> {Automatic, PointSize[0.025]}]]

ボックスの不確かさを大きくすると分類器が実行不可能になる：

Wolfram Language code:

RobustConvexOptimization[Norm[a], ForAll[{α, β}, {α∈Matrices[Dimensions[set1], Reals], β∈Matrices[Dimensions[set2], Reals], 
	-0.11α0.11, -0.11β0.11}, constraints], {a, b}]

不確かさが大きくなった集合を可視化すると，2つの集合に不確かさのボックスが重なるいくつかの点があることが分かる：

Wolfram Language code:

Show[Graphics[{EdgeForm[StandardGray], FaceForm[None], 
	Rectangle[# - 0.11, # + 0.11]& /@ Join[set1, set2]}], ListPlot[{set1, set2}, PlotMarkers -> {Automatic, PointSize[0.025]}]]

2つの3Dの点集合とを分離する二次多項式を求める．ただし，は不確かさの区間である：

Wolfram Language code:

{set1, set2} = Block[...];
dataplot = ListPointPlot3D[{set1, set2}, Sequence[...]]

DesignMatrixを使って2つの集合のために二次多項式データ行列を構築する：

Wolfram Language code: {data1, data2} = DesignMatrix[#, {x, x^2, y, y^2, x y}, {x, y}]& /@ {set1, set2};

分離するためには，集合1はを，集合2はを満足しなければならない：

Wolfram Language code: constraints = {Inactive[Plus][data1, α].a + b1, Inactive[Plus][data2, β].a + b-1};

を最小化することで分離多項式を求める：

Wolfram Language code:

res = RobustConvexOptimization[Norm[a], ForAll[{α, β}, {α∈Matrices[Dimensions[data1], Reals], β∈Matrices[Dimensions[data2], Reals], -0.02α0.02, -0.02β0.02}, constraints], {a, b}, MaxIterations -> 10 ^ 5]

2つの点集合を分離する多項式は以下で与えられる：

Wolfram Language code: poly = (a.{1, x, x^2, y, y^2, x y} + b) /. res

2つのデータ集合を分離する多項式をプロットする：

Wolfram Language code: Show[dataplot, ContourPlot3D[poly == 0, {x, -1.5, 1.5}, {y, -1.5, 1.5}, {z, -1, 1}, Sequence[...]]]

考えられる問題 (1)

問題の中には，ForAllの第1引数が評価されないために失敗するものがある：

Wolfram Language code:

parameters = {α, β};
parameterConstraints = {-α - β ≥ -1, α ≥ 0, β ≥ 0};
constraints = {x + 2y ≥ 3 + α, x ≥ -1 + β};

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[parameters, 
	parameterConstraints, constraints], {x, y}]

Evaluateを使って ForAllの第引数が確実に評価されるようにする：

Wolfram Language code:

RobustConvexOptimization[x + y, ForAll[Evaluate[parameters], 
	parameterConstraints, constraints], {x, y}]

Top

その他のラーニングリソース

テクニカルサポート

データサイエンス，金融，ビジネス

工学

科学とテクノロジー

教育のためのテクノロジー

教育イニシアチブ

使い始める

Grow Your Skills

Wolframと繋がる

大人用の教育プログラム

若者のための教育プログラム

読む

RobustConvexOptimization

詳細とオプション

例題

例 (2)

スコープ (29)

基本的な用法 (15)

線形変数制約 (5)

NormCone変数制約 (7)

SemidefiniteCone変数制約 (2)

オプション (3)

Method (2)

Tolerance (1)

アプリケーション (14)

幾何学問題 (2)

データフィッティング問題 (3)

製造問題 (3)

構造最適化問題 (1)

ポートフォリオの最適化 (2)

施設の場所問題 (1)

分類問題 (2)

考えられる問題 (1)

テキスト

CMS

APA

BibTeX

BibLaTeX

	最小化

	ただし

	変数制約	パラメータ制約



	$TemplateBox[{{{{a, (, {theta, _, l}, )}, ., x}, +, {b, (, {theta, _, l}, )}}}, Norm]<=c(theta_r).x+d(theta_r)$

	$a_0(theta)+a_1(theta) x_1+...+a_k(theta) x_k>=_(TemplateBox[{n}, SemidefiniteConeList])0$

RobustConvexOptimization

詳細とオプション

例題

例 (2)

スコープ (29)

基本的な用法 (15)

線形変数制約 (5)

NormCone変数制約 (7)

SemidefiniteCone変数制約 (2)

オプション (3)

Method (2)

Tolerance (1)

アプリケーション (14)

幾何学問題 (2)

データフィッティング問題 (3)

製造問題 (3)

構造最適化問題 (1)

ポートフォリオの最適化 (2)

施設の場所問題 (1)

分類問題 (2)

考えられる問題 (1)

関連項目

関連するガイド

履歴

テキスト

CMS

APA

BibTeX

BibLaTeX