Better return risk measures

Author: dcelisgarza

src/19_RiskMeasures/01_Base_RiskMeasures.jl

@@ -18,8 +18,8 @@ abstract type AbstractBaseRiskMeasure <: AbstractEstimator end
 function needs_previous_weights(::AbstractBaseRiskMeasure)
     return false
 end
-function smaller_is_better(::AbstractBaseRiskMeasure)
-    return true
+function bigger_is_better(::AbstractBaseRiskMeasure)
+    return false
 end
 const VecBaseRM = AbstractVector{<:AbstractBaseRiskMeasure}
 function needs_previous_weights(r::VecBaseRM)

src/19_RiskMeasures/23_NonOptimisationRiskMeasures.jl

@@ -10,10 +10,6 @@ end
 function MeanReturn(; w::Option{<:StatsBase.AbstractWeights} = nothing)
     return MeanReturn(w)
 end
-function smaller_is_better(::Union{<:MeanReturn,
-                                   <:RiskRatioRiskMeasure{<:MeanReturn, <:Any}})
-    return false
-end
 function (r::MeanReturn)(x::VecNum)
     return isnothing(r.w) ? Statistics.mean(x) : Statistics.mean(x, r.w)
 end
@@ -24,6 +20,27 @@ end
 function risk_measure_view(r::MeanReturn, ::Any, args...)
     return r
 end
+struct MeanReturnRiskRatio{T1, T2, T3} <: NonOptimisationRiskMeasure
+    rt::T1
+    rk::T2
+    rf::T3
+    function MeanReturnRiskRatio(rt::MeanReturn, rk::AbstractBaseRiskMeasure, rf::Number)
+        return new{typeof(rt), typeof(rk), typeof(rf)}(rt, rk, rf)
+    end
+end
+function MeanReturnRiskRatio(; rt::MeanReturn = MeanReturn(),
+                             rk::AbstractBaseRiskMeasure = ConditionalValueatRisk(),
+                             rf::Number = 0.0)
+    return MeanReturnRiskRatio(rt, rk, rf)
+end
+function factory(r::MeanReturnRiskRatio, pr::AbstractPriorResult, args...; kwargs...)
+    rt = nothing_scalar_array_selector(r.rt, pr)
+    rk = factory(r.rk, pr, args...; kwargs...)
+    return MeanReturnRiskRatio(; rt = rt, rk = rk, rf = r.rf)
+end
+function factory(r::MeanReturnRiskRatio, w::VecNum)
+    return MeanReturnRiskRatio(; rt = r.rt, rk = factory(r.rk, w), rf = r.rf)
+end
 struct ThirdCentralMoment{T1, T2} <: NonOptimisationRiskMeasure
     w::T1
     mu::T2
@@ -116,4 +133,4 @@ function (r::Skewness)(w::VecNum, X::MatNum, fees::Option{<:Fees} = nothing)
     return res / sigma^3
 end
 
-export MeanReturn, ThirdCentralMoment, Skewness
+export MeanReturn, ThirdCentralMoment, Skewness, MeanReturnRiskRatio

src/19_RiskMeasures/25_ExpectedRisk.jl

@@ -58,6 +58,16 @@ function expected_risk(r::RkRatioRM, w::VecNum, pr::Pr_RR, fees::Option{<:Fees}
     return expected_risk(r.r1, w, pr.X, fees; kwargs...) /
            expected_risk(r.r2, w, pr.X, fees; kwargs...)
 end
+function expected_risk(r::MeanReturnRiskRatio, w::VecNum, X::MatNum,
+                       fees::Option{<:Fees} = nothing; kwargs...)
+    return (expected_risk(r.rt, w, X, fees; kwargs...) - r.rf) /
+           expected_risk(r.rk, w, X, fees; kwargs...)
+end
+function expected_risk(r::MeanReturnRiskRatio, w::VecNum, pr::Pr_RR,
+                       fees::Option{<:Fees} = nothing; kwargs...)
+    return (expected_risk(r.rt, w, pr.X, fees; kwargs...) - r.rf) /
+           expected_risk(r.rk, w, pr.X, fees; kwargs...)
+end
 function expected_risk(r::AbstractBaseRiskMeasure, w::VecVecNum, args...; kwargs...)
     return [expected_risk(r, wi, args...; kwargs...) for wi in w]
 end

src/20_Optimisation/02_CrossValidation/01_Base_CrossValidation.jl

@@ -95,6 +95,9 @@ function PredictionResult(; res::NonFiniteAllocationOptimisationResult,
     return PredictionResult(res, rd)
 end
 struct SingletonVector{T} <: AbstractVector{T} end
+function SingletonVector()
+    return SingletonVector{Int}()
+end
 Base.length(::SingletonVector) = 1
 Base.getindex(::SingletonVector, args...) = 1
 Base.:*(M::Matrix, ::SingletonVector) = dropdims(M; dims = 2)
@@ -108,8 +111,7 @@ function expected_risk(pred::PredictionResult{<:Any,
                                               <:PredictionReturnsResult{<:Any, <:VecVecNum}},
                        r::AbstractBaseRiskMeasure; kwargs...)
     X = pred.rd.X
-    return [expected_risk(r, SingletonVector{Int}(), reshape(Xi, :, 1); kwargs...)
-            for Xi in X]
+    return [expected_risk(r, SingletonVector(), reshape(Xi, :, 1); kwargs...) for Xi in X]
 end
 struct MultiPeriodPredictionResult{T1} <: AbstractResult
     pred::T1
@@ -184,6 +186,17 @@ function expected_risk(ppred::PopulationPredictionResult, r::AbstractBaseRiskMea
                        kwargs...)
     return [expected_risk(pred, r; kwargs...) for pred in ppred.pred]
 end
+function sort_by_measure(ppred::PopulationPredictionResult, r::AbstractBaseRiskMeasure;
+                         kwargs...)
+    return sort(ppred.pred; by = x -> expected_risk(x, r; kwargs...),
+                rev = bigger_is_better(r))
+end
+function quantile_by_measure(ppred::PopulationPredictionResult, r::AbstractBaseRiskMeasure,
+                             q::Real; kwargs...)
+    sorted_predictions = sort_by_measure(ppred, r; kwargs...)
+    filter!(x -> isa(x.res, OptimisationSuccess), sorted_predictions)
+    return sorted_predictions[round(Int, quantile(length(sorted_predictions), q))]
+end
 function predict(res::NonFiniteAllocationOptimisationResult, rd::ReturnsResult)
     return PredictionResult(; res = res, rd = rd)
 end
@@ -248,4 +261,4 @@ function fit_and_predict(opt::NonFiniteAllocationOptimisationEstimator, rd::Retu
 end
 
 export PredictionResult, MultiPeriodPredictionResult, PopulationPredictionResult, predict,
-       fit_predict
+       fit_predict, sort_by_measure

src/20_Optimisation/08_Base_JuMPOptimisation.jl

@@ -66,15 +66,15 @@ function set_w!(model::JuMP.Model, X::MatNum, wi::Option{<:VecNum_VecVecNum})
     set_initial_w!(w, wi)
     return nothing
 end
-function process_model(model::JuMP.Model, ::JuMPOptimisationEstimator)
-    if JuMP.termination_status(model) == JuMP.OPTIMIZE_NOT_CALLED
-        return JuMPOptimisationSolution(; w = fill(NaN, length(model[:w])))
-    end
+function process_model(model::JuMP.Model, ::OptimisationSuccess)
     k = JuMP.value(model[:k])
     ik = !iszero(k) ? inv(k) : 1
     w = JuMP.value.(model[:w]) * ik
     return JuMPOptimisationSolution(; w = w)
 end
+function process_model(model::JuMP.Model, ::OptimisationFailure)
+    return JuMPOptimisationSolution(; w = fill(NaN, length(model[:w])))
+end
 function optimise_JuMP_model!(model::JuMP.Model, opt::JuMPOptimisationEstimator,
                               datatype::DataType = Float64)
     trials = Dict()
@@ -115,7 +115,7 @@ function optimise_JuMP_model!(model::JuMP.Model, opt::JuMPOptimisationEstimator,
         @warn("Failed to solve optimisation problem. Check `retcode.res` for details.")
         OptimisationFailure(; res = trials)
     end
-    return retcode, process_model(model, opt)
+    return retcode, process_model(model, retcode)
 end
 function set_portfolio_returns!(model::JuMP.Model, X::MatNum)
     if haskey(model, :X)