Relaxed risk budgeting
PortfolioOptimisers.RelaxedRiskBudgetingResult — Type
struct RelaxedRiskBudgetingResult{__T_jr, __T_rbr, __T_fb} <: NonRiskJuMPOptimisationResultHolds the solution, the budget and the fallback chain of a relaxed risk budgeting optimisation.
optimise returns it for a RelaxedRiskBudgeting. The model reads the covariance matrix of the prior and resolves no risk measure, so the result has no r, and it is a NonRiskJuMPOptimisationResult. A name that is not a field resolves through rbr first, so res.rkb is the budget of the model. Every other name, and the property w, then resolves through jr, the JuMPOptimisationResult that the result holds.
Fields
jr: TheJuMPOptimisationResultthat holds the resolved bundle of the optimiser, the return code, the solution and the model.
rbr: The resolved risk budget of the model, anAbstractResolvedRiskBudgeting.
fb: The fallback chain that answered this result: the(estimator, result)pair of every attemptoptimisemade before this one, in the order they ran, ornothingwhen the estimator it was asked of answered (seeFbChain).
Constructors
RelaxedRiskBudgetingResult(; jr::JuMPOptimisationResult, rbr::AbstractResolvedRiskBudgeting, fb::Option{<:OptE_Opt_FbChain}) -> RelaxedRiskBudgetingResultKeywords correspond to the struct's fields.
Related
PortfolioOptimisers.BasicRelaxedRiskBudgeting — Type
struct BasicRelaxedRiskBudgeting <: RelaxedRiskBudgetingAlgorithmSelects Model (A) of RelaxedRiskBudgeting, where the standard deviation of the portfolio alone bounds $\psi$.
The objective of this model is zero exactly when the contributions meet the budget, so the model gives the risk budgeting portfolio when no other row binds. Model (A) of [244] is the second-order cone model of [245] with a target return.
Related
RelaxedRiskBudgetingAlgorithmRegularisedRelaxedRiskBudgetingRegularisedPenalisedRelaxedRiskBudgetingRelaxedRiskBudgeting
References
- [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Model (0), Equations 5 to 11, and Model (A), Equations 12 to 17. The original source of this formulation was not found. The formulation follows this work and is not checked against the original.
- [245] H. Mausser and O. Romanko. Computing equal risk contribution portfolios. IBM Journal of Research and Development 58, 5:1–5:12 (2014).
PortfolioOptimisers.RegularisedRelaxedRiskBudgeting — Type
struct RegularisedRelaxedRiskBudgeting <: RelaxedRiskBudgetingAlgorithmSelects Model (B) of RelaxedRiskBudgeting, which adds a regulating term $\rho$ that the standard deviation of the portfolio bounds.
The term raises the price of the standard deviation in the objective, so the model trades the budget for a lower standard deviation. The objective is not zero at the budget, so the solution can leave the budget also when no other row binds.
Related
RelaxedRiskBudgetingAlgorithmBasicRelaxedRiskBudgetingRegularisedPenalisedRelaxedRiskBudgetingRelaxedRiskBudgeting
References
- [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Section 3.2, Model (B), Equations 21 to 27.
PortfolioOptimisers.RegularisedPenalisedRelaxedRiskBudgeting — Type
struct RegularisedPenalisedRelaxedRiskBudgeting{__T_p} <: RelaxedRiskBudgetingAlgorithmSelects Model (C) of RelaxedRiskBudgeting, where the variances of the single assets, times the penalty p, bound the regulating term $\rho$.
The term reads the diagonal of the covariance matrix, and not the whole matrix as Model (B) does. So it limits the weight of an asset of high variance. Section 3.3 of [244] uses this to keep the contributions nearer to the budget than Model (B) does. A larger p gives the term more strength. The objective is not zero at the budget, so the solution can leave the budget also when no other row binds.
Fields
p: Penalty $\lambda$ of the regulating term. It multiplies $\boldsymbol{w}^\intercal \mathbf{\Theta} \boldsymbol{w}$, the variances of the single assets times the squares of their weights.
Constructors
RegularisedPenalisedRelaxedRiskBudgeting(; p::Number = 1.0) -> RegularisedPenalisedRelaxedRiskBudgetingKeywords correspond to the struct's fields.
Validation
isfinite(p)andp > 0. Otherwise aDomainErrornamesp.
Related
RelaxedRiskBudgetingAlgorithmBasicRelaxedRiskBudgetingRegularisedRelaxedRiskBudgetingRelaxedRiskBudgeting
References
- [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Section 3.3, Equations 28 and 30, and Section 3.4, Model (C), Equations 31 to 37.
PortfolioOptimisers.RelaxedRiskBudgeting — Type
struct RelaxedRiskBudgeting{__T_opt, __T_rba, __T_wi, __T_alg, __T_fb, __T_mtx_sqrt} <: JuMPOptimisationEstimatorOptimises the portfolio whose assets, or whose factors, take stated shares of the variance, through a model of second-order cones.
rba selects the budget, alg selects the model, and opt gives the prior, the solver and every other constraint. The model reads the covariance matrix alone and resolves no risk measure, so its result carries no r. Model (A) gives the risk budgeting portfolio when no row of opt binds at that portfolio. A row that binds, such as a target return, moves the contributions away from the budget. Models (B) and (C) can leave the budget also when no row binds. RiskBudgeting states the budget as a row of the logarithm, and it reads any risk measure.
Mathematical definition
The risk budgeting condition asks that each asset contribute the share $b_{i}$ of the variance, $w_{i} (\mathbf{\Sigma} \boldsymbol{w})_{i} = b_{i} \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$. [245] writes the condition for equal shares as a second-order cone programme, and [244] adds a target return and a regulating term to it. The library writes Models (A), (B) and (C) of [244] with the shares of a general budget:
\[\begin{align} \underset{\boldsymbol{w},\, \psi,\, \gamma,\, \boldsymbol{\zeta}}{\min} \quad & \psi - \gamma \\ \text{s.t.} \quad & \boldsymbol{\zeta} = \mathbf{\Sigma} \boldsymbol{w}\,, \quad \boldsymbol{\zeta} \geq \boldsymbol{0}\,, \\ & w_{i} \zeta_{i} \geq b_{i} \gamma^{2}\,, \quad i = 1, \ldots, n\,, \\ & \boldsymbol{w} \in \mathcal{W}\,. \end{align}\]
The model in alg adds the cones that bound $\psi$. Model (A), BasicRelaxedRiskBudgeting, adds one:
\[\begin{align} \psi &\geq \lVert \mathbf{G} \boldsymbol{w} \rVert_{2}\,. \end{align}\]
Model (B), RegularisedRelaxedRiskBudgeting, and Model (C), RegularisedPenalisedRelaxedRiskBudgeting, add a regulating term $\rho$:
\[\begin{align} \psi^{2} &\geq \lVert \mathbf{G} \boldsymbol{w} \rVert_{2}^{2} + \rho^{2}\,, \\ \rho^{2} &\geq n\, \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w} \quad \text{in Model (B)}\,, \\ \rho^{2} &\geq n \lambda\, \boldsymbol{w}^\intercal \mathbf{\Theta} \boldsymbol{w}\,, \quad \mathbf{\Theta} = \mathrm{diag}(\mathbf{\Sigma})\,, \quad \text{in Model (C)}\,. \end{align}\]
The variables $\psi$, $\gamma$ and $\rho$ are $\sqrt{n}$ times the variables of [244], so the objective is $\sqrt{n}$ times its objective and the weights are the same. With $b_{i} = 1/n$ the rows are its Equations 13 to 15, 22 to 25 and 32 to 35. Its target return, Equations 16, 26 and 36, is the lower bound of the return that opt.ret can state. It is then a row of $\mathcal{W}$.
In Model (A), for a budget whose shares sum to one, the rows give the chain $\gamma^{2} = \gamma^{2} \sum_{i} b_{i} \leq \sum_{i} w_{i} \zeta_{i} = \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w} \leq \psi^{2}$. So the objective is not below zero, and it is zero exactly when $w_{i} \zeta_{i} = b_{i} \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$ for every $i$, which is the risk budgeting condition. In Models (B) and (C) the regulating term is at its bound at the optimum, so $\psi$ is larger than the standard deviation, and the objective is not zero at the budget. The optimum then trades the budget for a lower $\psi$.
Where:
- $\boldsymbol{w}$: Portfolio weights vector $N \times 1$.
- $\psi$: Upper bound of the standard deviation of the portfolio. In Models (B) and (C) it also bounds the regulating term.
- $\gamma$: Lower bound of $\sqrt{w_{i} \zeta_{i} / b_{i}}$ over the assets.
- $\boldsymbol{\zeta}$: Marginal risks, $\mathbf{\Sigma} \boldsymbol{w}$. So $w_{i} \zeta_{i}$ is the contribution of asset $i$ to the variance.
- $b_{i}$: Share of asset $i$ in the budget
rba.rkb, its entry divided by the sum of the entries. So a budget of1:5and a budget of(1:5) / 15give the same portfolio. - $n$: Number of entries of the budget, which is the number of assets, or the number of factors of a
FactorRiskBudgeting. - $\mathcal{W}$: Feasible weight set, the portfolios that the constraints of the optimiser admit. It holds the weight bounds, the budget, the target return and every other row of
opt. The budgeted weights are not negative, because $\boldsymbol{\zeta} \geq \boldsymbol{0}$ and the cones give $w_{i} \geq 0$. - $\mathbf{G}$: Covariance factor, with $\mathbf{G}^\intercal \mathbf{G} = \mathbf{\Sigma}$. It need not be square, and $\lVert \mathbf{G} \boldsymbol{w} \rVert_{2}^{2} = \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$. It is the
cholof the prior, or the transpose of the square root of $\mathbf{\Sigma}$ thatmatrix_square_roottakes undermtx_sqrt. - $\mathbf{\Sigma}$: Covariance matrix of the prior.
- $\rho$: Regulating term of Models (B) and (C).
- $\lambda$: Penalty
pofRegularisedPenalisedRelaxedRiskBudgeting. - $\mathbf{\Theta}$: Diagonal matrix of the variances of the single assets.
Factor risk budgeting
With a FactorRiskBudgeting the budget is over the factor weights $\boldsymbol{w}_{1}$. So the cones of the budget pair $[\boldsymbol{w}_{1}]_{j}$ with $\zeta_{j}$ and read the share of factor $j$. The marginal risks and the cones on $\psi$ read the whole portfolio:
\[\begin{align} \boldsymbol{w} &= \begin{cases} \mathbf{B}_{1} \boldsymbol{w}_{1} & \text{if } \texttt{flag} = \texttt{false}\,, \\ \mathbf{B}_{1} \boldsymbol{w}_{1} + \mathbf{B}_{2} \boldsymbol{w}_{2} & \text{if } \texttt{flag} = \texttt{true}\,, \end{cases} \\ \boldsymbol{\zeta} &= \mathbf{B}_{1}^\intercal \mathbf{\Sigma} \boldsymbol{w}\,, \qquad \psi \geq \lVert \mathbf{G} \boldsymbol{w} \rVert_{2} \quad \text{in Model (A)}\,. \end{align}\]
So $[\boldsymbol{w}_{1}]_{j} \zeta_{j}$ is the Euler contribution of factor $j$ to $\boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$, the value that factor_risk_contribution reports. With flag = true the variance splits into the factor contributions and the off-factor contribution $c_{2} = \boldsymbol{w}_{2}^\intercal \mathbf{B}_{2}^\intercal \mathbf{\Sigma} \boldsymbol{w}$, which takes no budget. The chain of Model (A) then gives $\gamma^{2} \leq \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w} - c_{2}$. So the objective can fall below zero by the term $c_{2}$, and in general its optimum is not the optimum of RiskBudgeting. The penalty of Model (C) reads the decision vector, $\boldsymbol{w}_{1}$, or $\boldsymbol{w}_{1}$ followed by $\boldsymbol{w}_{2}$, with the covariance $\mathbf{P}^\intercal \mathbf{\Sigma} \mathbf{P}$ of its basis $\mathbf{P}$.
With hedge = true the model adds the rows $\mathbf{B}_{2}^\intercal \mathbf{\Sigma} \boldsymbol{w} = \boldsymbol{0}$. They are the first-order condition of the variance in $\boldsymbol{w}_{2}$, so $c_{2} = 0$, and the model is the model above on the factor covariance $(\mathbf{B}^\intercal \mathbf{\Sigma}^{-1} \mathbf{B})^{-1}$. Model (A) is then exact: when no other row binds, its optimum is the optimum of RiskBudgeting under Variance. The cost is that the weights lie in a subspace of dimension $N_{f}$, so a weight bound that the free off-factor weights meet can make the model infeasible.
Where:
- $\boldsymbol{w}_{1}$: Factor weights, one entry for each of the $N_{f}$ factors.
- $\boldsymbol{w}_2$: Off-factor weights, one entry for each direction of the null space of $\mathbf{B}^\intercal$. There are $N - N_f$ of them when $\mathbf{B}$ has full column rank.
- $\mathbf{B}$: Loading matrix, of size $N \times N_{f}$. It is
rr.L. - $\mathbf{B}_{1}$: Factor basis, the pseudoinverse of $\mathbf{B}^\intercal$.
- $\mathbf{B}_{2}$: Off-factor basis, an orthonormal basis of the null space of $\mathbf{B}^\intercal$.
- $\mathbf{P}$: Basis of the decision vector, $\mathbf{B}_{1}$, or $[\mathbf{B}_{1} \; \mathbf{B}_{2}]$ when
flag = true. - $c_{2}$: Off-factor contribution to the variance.
Fields
opt:JuMPoptimiser configuration.
rba: Risk budget algorithm.
wi: Initial portfolio weights for warm-starting the solver.
alg: Model of the relaxation, aRelaxedRiskBudgetingAlgorithm.
fb: Fallback result or estimator.
mtx_sqrt: Square-root algorithm of the covariance matrix that the cones read, when the prior carries nochol, ornothingfor the plain Cholesky factor, which raises aLinearAlgebra.PosDefExceptionon a matrix that is not positive definite. The default takes the square root of the eigendecomposition of a singular positive semidefinite matrix.matrix_square_rootstates each algorithm.
Constructors
RelaxedRiskBudgeting(; opt::JuMPOptimiser, rba::TD{<:RiskBudgetingAlgorithm} = AssetRiskBudgeting(), wi::TD_Option{<:VecNum} = nothing, alg::RelaxedRiskBudgetingAlgorithm = BasicRelaxedRiskBudgeting(), fb::TDO_Option{<:OptE_Opt} = nothing, mtx_sqrt::Option{<:AbstractMatrixSquareRootAlgorithm} = EigenFallbackSquareRoot()) -> RelaxedRiskBudgetingKeywords correspond to the struct's fields. A field of the type TD, TD_Option or TDO_Option can hold a TimeDependent schedule in place of a static value. The budgeting algorithm with its budget, the initial weights and the fallback define the problem, so a cross-validation fold loop resolves them for each fold. An optimise outside a fold loop uses the static default of each field. The default of wi and of fb is nothing. The model alg and the square-root algorithm mtx_sqrt control the formulation, and they cannot hold a schedule.
Validation
- If
wiis provided:!isempty(wi). Otherwise anIsEmptyError. - A schedule in
fb:bind !== :nearest. - A part that states no source and reads the raw returns, beside a part that states
x_src = ExcessSource(), logs one warning that names its path, seewarn_raw_readers. The constructor then builds the estimator as configured.
Propagated parameters
factory passes its arguments on to these @fprop fields:
View parameters
RelaxedRiskBudgeting defines its own port_opt_view method rather than deriving one from field tags.
- The method reads the returns matrix
Xas its third argument. Whenopt.peholds a prior result, the method usesopt.pe.Xin place ofX. So the views of the children read the observations of the prior, and not the matrix of the caller. optrecurses throughport_opt_viewwith that matrix.rbarecurses with the indices alone.fbrecurses throughview_childwith that matrix.wiis sliced to the selected assets.algandmtx_sqrtpass unchanged.
Observation weight parameters
obs_weights_view indexes these fields to the selected observations:
opt: Recursively indexed throughobs_weights_view.rba: Recursively indexed throughobs_weights_view.fb: Recursively indexed throughobs_weights_view.
Related
optimiseRelaxedRiskBudgetingResultJuMPOptimisationEstimatorRiskBudgetingRelaxedRiskBudgetingAlgorithmAssetRiskBudgetingFactorRiskBudgetingfactoryport_opt_viewobs_weights_view
References
- [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Model (0), Equations 5 to 11, and Model (A), Equations 12 to 17. The original source of this formulation was not found. The formulation follows this work and is not checked against the original.
- [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Model (B), Equations 21 to 27, and Model (C), Equations 31 to 37.
- [245] H. Mausser and O. Romanko. Computing equal risk contribution portfolios. IBM Journal of Research and Development 58, 5:1–5:12 (2014).
- [12] D. Cajas. Advanced Portfolio Optimization: A Cutting-edge Quantitative Approach (Springer Nature Switzerland, 2025). Section 10.1.2, Equations 10.5 and 10.6, for the rotated cone with a general budget.
- [223] T. Roncalli and G. Weisang. Risk parity portfolios with risk factors. Available at SSRN 2155159 (2012). Problem 8 and Section 4.1.1, for the budget over the factors.
PortfolioOptimisers.factory — Method
factory(a, args...; kwargs...) -> a
factory(a::AbstractArray{<:Union{Nothing, AbstractEstimator, AbstractAlgorithm,
AbstractResult, StatsBase.CovarianceEstimator}},
args...; kwargs...) -> AbstractArrayRebuild an estimator, an algorithm or a result with runtime values. These two methods are the leaf and the array step of the traversal.
factory and port_opt_view are the two propagation mechanisms of this library. factory passes runtime values, such as prior moments, observation weights and previous portfolio weights, down a tree of composed structs. port_opt_view passes an index selection, a subset of the assets, down the same tree.
factory is a traversal, so it owns the identity on every leaf, as fmap in Functors.jl and adapt_structure in Adapt.jl do. A value that has no method of its own comes back with no change: a data field, a scalar, nothing, a set of observation weights and a covariance estimator of StatsBase. So a @propagatable struct sends each @fprop field to factory directly, whatever the field holds.
The array method is the one forwarding contract for every propagation field that holds an array of estimators, algorithms, results or covariance estimators. It applies factory to each element, and it forwards args... and kwargs... with no change. A family that accepts an array of them needs no method of its own. A family that needs more than the forward defines its own, more specific method. A concrete element type, through concrete_typed_array_if_abstract, is an example. An array of data, such as a vector of numbers, is a leaf, and it comes back with no change and with no copy.
Algorithm
The leaf method:
- Return
awith no change, and dropargs...andkwargs.... This method is the leaf of the recursion. Because of it, a call of the verb on a type with no tags returns the value and raises no error.
The array method:
- For each element
aiofa, callfactoryonai, and forwardargs...andkwargs...with no change. - Collect the results into a new array of the shape of
a, in the order ofa, and return it.
A @propagatable struct always has a generated method that is more specific than the leaf method. If the struct has at least one @fprop or @wprop field, that method builds the struct again with its keyword constructor. It sends each @fprop field through factory and each @wprop field through _wprop. If the struct has no such field, that method returns x.
The leaf method does not fill a nothing field. A weights field that must take the incoming weights when it holds nothing carries @wprop, and it goes to _wprop.
Arguments
a: Any value, which the leaf method returns with no change. For the array method, an array of estimators, algorithms, results, covariance estimators ornothing, which it rebuilds one element at a time.args...: Positional arguments. The leaf method ignores them, and the array method forwards them.kwargs...: Keyword arguments. The leaf method ignores them, and the array method forwards them.
Returns
a: The input with no change, for the leaf method.v::AbstractArray: The rebuilt elements, in an array of the shape ofa, for the array method.
Examples
julia> factory(nothing, 1, 2; x = 3)julia> factory([1.0, 2.0], 1, 2; x = 3)2-element Vector{Float64}: 1.0 2.0julia> factory(MeanValue())MeanValue w ┴ nothingRelated
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> EqualWeighted{_A, _B, _C, _D, _E, Bool} where {_A, _B, _C, _D, _E}
Returns opt unchanged.
This is the fallback factory of an optimisation estimator or result. An estimator whose parameters change at each step of an optimisation adds its own method. A precomputed result in a field of an estimator, for example in fb, reaches this method when factory gives the estimator the weights of the previous fold. A precomputed result does not change.
Related
PortfolioOptimisers.port_opt_view — Method
port_opt_view(
rrb::RelaxedRiskBudgeting,
i,
X::AbstractMatrix{<:Union{Number, AbstractJuMPScalar}},
args...
) -> RelaxedRiskBudgeting{JuMPOptimiser{__T_pe, __T_slv, __T_cbe, __T_bgt, __T_fees, __T_ret, __T_sca, __T_sc, __T_so, __T_strict, __T_cache}, _A, _B, <:RelaxedRiskBudgetingAlgorithm} where {__T_pe, __T_slv, __T_cbe, __T_bgt, __T_fees, __T_ret, __T_sca, __T_sc, __T_so, __T_strict, __T_cache, _A, _B}
Return the view of a RelaxedRiskBudgeting at the assets i.
The ## View parameters subsection of RelaxedRiskBudgeting states how the method takes the view of each field.
Arguments
rrb: The optimiser.i: Indices of the assets that the view keeps.X::MatNum: Returns matrix of the caller. The method uses the matrix of the prior in its place whenrrb.opt.peholds a prior result.args...: Not read.
Returns
RelaxedRiskBudgeting: A new optimiser, built through the keyword constructor.
Related
PortfolioOptimisers._optimise — Function
_optimise(rrb::RelaxedRiskBudgeting, rd::ReturnsResult = ReturnsResult();
str_names::Bool = false, save::Bool = true, blocks::Tuple = (),
kwargs...) -> RelaxedRiskBudgetingResultBuild the model of a RelaxedRiskBudgeting, solve it, and return its result.
optimise reaches this method through shared_series_solve, which drops the observations of a Shared Series gap before the solve.
Algorithm
- Replace each schedule of
rrbwith its static default throughreset_time_dependent_estimator. - Resolve
rrb.optagainstrdwithresolve_jump_optimiser, with the blocks ofblocks, givingattrs. It holds the prior, the block Results, the fees, the return terms and the Investable Mask. - Take the view of
rrband ofrdat the investable assets withinvestable_view. Both are unchanged when every asset is investable. - Bind the benchmark of each
DataBenchmarkTrackingterm tordwithbind_data_benchmark. - Build a new model. Register the scales with
set_model_scales!, the number of observations withset_model_observations!, and the expressionk = 1withset_maximum_ratio_factor_variables!, becauseMinimumRiskdoes not scale the weights. - Add the weights, the cones and the weight constraints with
set_relaxed_risk_budgeting_constraints!, givingrbr. - Add the constraints of every block and the return terms of
rrb.optwithassemble_jump_model!. - Set the objective
MinimumRisk, which minimisesrisk, and solve withoptimise_JuMP_model!, givingretcodeandsol. - Build the result. It holds
attrs,retcode,sol, the model whensaveistrue, andrbr.
Arguments
rrb::RelaxedRiskBudgeting: The optimiser.rd: The returns result to use. Whenrrb.opt.peis a prior result, the solve does not readrd, except to fit the loadings ofFactorRiskBudgetingwhen no other source holds them. A fallback or a clustering step can still read it.str_names::Bool:truegives each variable and each row of the model its string name.save::Bool:truekeeps the model in the result.blocks::Tuple = (): The blocks after the block of the optimiser of the head, the keywordblocksofresolve_jump_optimiser. The head adds the rows of every block to its model withassemble_jump_model!. The fallback chain ofoptimisepasses the keyword to each member, so a fallback solves on the same blocks.kwargs...: Passed on toresolve_jump_optimiser.
Returns
RelaxedRiskBudgetingResult: The result, withfb = nothing.optimiseruns the fallback chain when the solve fails.
Related
PortfolioOptimisers.needs_previous_weights — Method
needs_previous_weights(opt::RelaxedRiskBudgeting) -> Any
Return true when a part of opt needs the previous portfolio weights.
The parts are the schedules of the time-dependent fields, the JuMPOptimiser opt.opt and the fallback opt.fb. A turnover constraint or a fee on the turnover is a part that needs them.
Returns
Bool:truewhen any part answerstrue.
Related
References
- [12]
- D. Cajas. Advanced Portfolio Optimization: A Cutting-edge Quantitative Approach (Springer Nature Switzerland, 2025).
- [223]
- T. Roncalli and G. Weisang. Risk Parity Portfolios with Risk Factors. Available at SSRN 2155159 (2012).
- [244]
- V. Gambeta and R. Kwon. Risk Return Trade-Off in Relaxed Risk Parity Portfolio Optimization. Journal of Risk and Financial Management 13, 237 (2020).
- [245]
- H. Mausser and O. Romanko. Computing Equal Risk Contribution Portfolios. IBM Journal of Research and Development 58, 5:1–5:12 (2014).