bqth29
commented
10 months ago Hi Sean! Thanks for your interest in our implementation of the SB algorithm.
This package actually already handles the Markowitz portfolio integer optimization problem thanks to the Markowitz API in the simulated_bifurcation.models module. However, the current implementation only allows optimization on a single timestamp instead of several consecutive ones, i.e. solving:
$$\hbox{argmax } w^T \mu - \frac{\gamma}{2} w^T \Sigma w$$
for a given risk coefficient $\gamma$, expected return vector $\mu$, and covariance matrix $\Sigma$.
Adding a sequential version of this problem with multiple coupled timestamps and a global optimization as a sum (similar to the paper you mentioned) is definitely something we will implement for the next release of the package. The goal will be to extend and generalize the API so that the problem becomes:
$$\hbox{argmax } \sum{t = 1}^{T} w{t}^{T} \mu{t} - \frac{\gamma}{2} w{t}^{T} \Sigma{t} w{t} - \Delta w_t^T \Lambda_t \Delta w_t$$
where $\Lambda_t$ accounts for the rebalancing cost resulting from the stock difference $\Delta w_t = wt - w{t-1}$ between two consecutive timestamps.
We will let you know when this feature is added to the package. In the meantime, you can try the Markowitz API included in the last release of the package.
Edit: after further checks, it appears the
MarkowitzAPI may not work as expected since the source code was not updated with the new Polynomial API introduced by version1.2.0. Please find below a way to implement a Markowitz model using thesimulated_bifurcationpackage (the current code will be fixed at the same time as the development of the new feature).
Given a covariance matrix and an expected_return vector (as numpy arrays or torch tensors), you can set the risk coefficient of the Markowitz model to match your risk aversion. You can also choose the number of bits to encode the stocks. By default, this value is 1, which means that the decision is binary (either hold an asset, or sell it). Increasing the number of bits used to encode the weights can refine this selection by weighting the set of selected stocks (but unfortunately this can reduce the precision by introducing new spins in the SB optimization).
from typing import Optional, Union
import numpy as np
import torch
from simulated_bifurcation.polynomial import IntegerPolynomial
class Markowitz(IntegerPolynomial):
"""
A representation of the Markowitz model for portfolio optimization.
Portfolio only takes integer stocks.
"""
def __init__(
self,
covariance: Union[torch.Tensor, np.ndarray],
expected_return: Union[torch.Tensor, np.ndarray],
risk_coefficient: float = 1,
number_of_bits: int = 1,
dtype: torch.dtype = torch.float32,
device: str = "cpu",
) -> None:
# Data
super().__init__(
-risk_coefficient / 2 * covariance,
expected_return,
None,
number_of_bits,
dtype,
device,
)
self.risk_coefficient = risk_coefficient
@property
def covariance(self) -> torch.Tensor:
return -(2 / self.risk_coefficient) * self.matrix
@property
def expected_return(self) -> torch.Tensor:
return self.vector
@property
def portfolio(self) -> Optional[torch.Tensor]:
return (
self.sb_result[:, torch.argmax(self(self.sb_result.t())).item()]
if self.sb_result is not None
else None
)
@property
def gains(self) -> float:
return self(self.portfolio) if self.portfolio is not None else 0.0
# Create the Markowitz model
markowitz = Markowitz(
covariance,
expected_return,
risk_coefficient = 1,
number_of_bits = 1,
)
# Optimize with SB
markowitz.maximize()
# Get the stocks for each asset as a tensor
print(markowitz.portfolio)
# Get the expected gains from this portfolio (objective function)
print(markowitz.gains)If you have any other ideas, suggestions, or requests for models to add to the package to expand the pool of problems that can be solved with the SB API, please feel free to open new issues like this one and we will be happy to have a look at it.
seanlaw
BusyBeaver-42
In this paper, they demonstrate the use of SB for solving the portfolio integer optimization problem. I'm sure you are super busy but it would be useful to reproduce this work on different number of assets in order to demonstrate both the quality as well as scalability of this package.