Portfolio Optimization¶

In this tutorial, we consider portfolio optimization. A portfolio is a combination of financial instruments such as stocks and bonds. Unlike bank deposits, these financial instruments are risky assets with uncertain future payouts and returns. When investing in such risky assets, it is advisable to construct an appropriate portfolio and diversify investments across assets that are not highly correlated. In this way, if the value of one asset falls significantly, it can be covered by another asset that is not significantly correlated with its price.

In general, diversified investment involve a trade-off between risk and return. Portfolios must be constructed to properly reflect this trade-off, limiting return variability and risk of loss while maximizing return.

Here, we will use Fixstars Amplify to optimize the portfolio. The optimization uses estimates based on the historical data method. The historical data method is an estimation method that uses historical price data to determine assets' expected returns and risks. In this sample program, we will explain the following:

• Historical data
• Formulation
• Execution and evaluation
• Operation simulation

This sample program is intended to demonstrate an optimization application using Fixstars Amplify. The user is responsible for performing actual operations based on the information provided in this sample program.

Historical data¶

First, we create time series data of stock prices. We prepared dummy simulation data (dummy_stock_price.csv) based on geometric Brownian motion. In the simulation, the parameters of the stochastic differential equation are determined so that the distribution of profit rate, volatility (risk), and correlation coefficient among stocks matches the price movements of each stock in the NASDAQ index from 2023 to the first half of 2024 as much as possible. Please refer to the end of this tutorial to learn how to obtain real data.

The following load_stock_prices() function can be used to load simulation data. The stock price data is represented as a pandas.DataFrame, with the stock name (or ticker name or code) as a column, the date as a row, and the closing price of each stock on each day as a value. For example, the following table shows the data.

Formulation¶

We are ready to obtain time series data on stock prices. Now, we formulate the formulation to achieve the optimal portfolio.

First, we pick up the candidate stocks to invest in. Suppose that we choose $n$ financial instruments: financial instrument $0$, $1$, $\ldots$, and financial instrument $n -1$. Let $w_i$ (%) be the ratio of investment in financial instrument $i$ to the total investment amount, the constraint that $w_i$ must satisfy the following equation:

$$ \sum_{i=0}^{n-1} w_i = 100 $$

For the convenience of optimization using Amplify, $w_i$ is assumed to be an integer value. Also, since investing a large percentage in a single financial instrument is risky, we limit the percentage invested in a single financial instrument to 20% or less of the total amount invested.

$$ 0 \leq w_i \leq 20 $$

Some ways exist to create a portfolio from these $n$ candidate financial instruments. Among them, we consider a “good portfolio” with a high expected rate of return and low risk.

First, for the expected rate of return, we will simply adopt the average rate of return for any $d$ business day in the stock price data when operated during that period.

When a stock is invested for a certain period of time, the value at the beginning is $p_{s}$, and the value at the end is $p_{e}$, and the rate of return $r$ is defined as:

$$ r = (p_{e} - p_{s}) / p_{s} $$

The expected rate of return on the entire portfolio $r_p$ is obtained by the following equation with the rate of return on financial instrument $i$ $r_i$:

$$ r_p = \sum_{i=0}^{n-1} r_i w_i $$

If other indicators can provide a better numerical assessment of expected return (or “goodness” of a stock), you can use them.

Next, we consider risk. Risk in diversified investments is usually the variance of the total portfolio rate of return $\sigma^2_p$, which can be described using the covariance of the rates of return of financial instruments $i$ and $j$ $\sigma_{i,j}$ as the following equation:

$$ \sigma_p^2 = \sum_{i=0}^{n-1} \sum_{j=0}^{n-1} w_i w_j \sigma_{i,j}. $$

We have now defined the rate of return and risk. To make the rate of return $r_p$ larger and the risk $\sigma_p^2$ smaller, the following mean and variance model $f(w_i)$ is used as the objective function and optimized to minimize it.

$$ f(w_i) = - r_p + \frac{\gamma}{2} \sigma_p^2. $$

Here, $\gamma$ is a parameter related to the balance between rate of return and risk. The portfolio optimization implemented below uses $\gamma=20$ as the default setting. Larger $\gamma$ means more emphasis is placed on risk reduction.

Implementation¶

We will formulate the above model using the Amplify SDK. First, we define an auxiliary function, calculate_return_rates(), which calculates the rate of return. This function returns a two-dimensional array that contains the return rate for a given time-series data price for the number of days num_days_operation from the given date and time for each starting date and each stock.

Next, we define the formulation and optimization functions.

The following optimize_portfolio() function takes historical stock price time series data, the number of days to run, and other parameters necessary for optimization. It returns an optimized portfolio, along with its rate of return and variance.

The function's gamma parameter indicates the balance between the rate of return and risk reduction in portfolio construction; the higher the value, the greater the degree to which risk reduction is attempted. Also, max_w represents the maximum percentage of the total investment that can be made in a single issue.

(Note: for the convenience of the QUBO formulation, a larger max_w is a more complex optimization problem because it increases the number of variables sent to the machine.)

constraint_weight and timeout are parameters related to the accuracy of the solution. They represent the weight of converting the constraints to penalty functions and the execution time of Amplify AE, respectively. For more information, see the documents “Constraints and Penalty Functions” and “Solver Client”.

The larger (more complex) the problem, the larger the run time should be, but since this is a tutorial, we set it to 5 seconds.

Execution and evaluation¶

Now that the implementation is complete, we construct the optimal portfolio using the dummy data in practice. First, we create a pd.DataFrame representing the stock price data.

The following stock_prices contains fictitious stock price data. The data period is for two years (500 business days) from 2023 to 2024, and the stocks are for 100 fictitious companies with color names in their company names.

For example, look at the price movements of salmon, darkslategray, and hotpink stocks over a two years.

Next, we determine the date to start the operation. We assume that the operation starts on January 1, 2024, for validation after the investment period. (In actual portfolio optimization, the operation would start when the optimized portfolio is obtained. Hence, the validation will be done in the future.)

In optimization, only data past the start date can be used. In this case, we will use one year of data backward from the start date for optimization. From the stock_prices created earlier, we will use only the stock price data for 2023 as historical data.

Optimization¶

Using the optimize_portfolio() function implemented above, we obtain an optimized portfolio based on time series data of stock prices. The rate of return is calculated based on an investment period of 20 business days.

We visualize the portfolio using a pie chart.

Evaluation¶

Using the above portfolio, we plot a histogram of the profit margin for any 20 business days in 2024 to see how much profit margin can be obtained with minimal risk.

For simplicity, we assume that the portfolio can be purchased and sold at the same price as the closing price on the operation's start and end dates. As a comparison, we will also evaluate portfolios created with the following policies.

• Invest all funds in stocks with the highest average return
• Allocate funds equally to all stocks

As the displayed histogram is closer to the right side, the rate of return is higher. If the histogram is growing sideways, the rate of return is more varied, and the risk is more significant, especially if the rate of return is negative.

The optimized portfolio has a lower average rate of return than investing in a single stock, but the variance in the rate of return is smaller. In addition, we can expect that stocks with higher overall rates of return are selected compared to the case in which all stocks are invested equally.

By changing the parameter $\gamma$, which represents the degree of risk aversion, we can adjust the trade-off between the rate of return and risk to suit our investment objectives. Try changing the argument of the optimize_portfolio() function.

Application: Operation simulation¶

The implemented portfolio optimization will be used to simulate operations more realistically.

In the simulation, the operation begins on January 1st, 2024, and consists of 10 rounds, each round being 50 business days long. In each round, the portfolio is optimized using data from 50 business days before the start date, and the stocks are purchased and sold 20 business days later. All the funds from the sale will be used to purchase the next cycle. However, to make it more realistic, it is assumed that 20% of the profit from each sale will be deducted for taxation. In addition, the purchase and sale amounts will be determined randomly within the range of 0 to 1% increase over the closing price.

The following diagram illustrates the flow of such an operation.

We create a function that simulates one round. Note that the portfolio must be made using data before the operation's start date.

We create a simulate_stick_operation() function that repeatedly simulates multiple trading rounds using the simulate_stock_trading() function. The function will return a historical record of each round (purchase date, purchase amount, sale date, sale amount).

In the following cell, the simulation is repeated ten times for 20 days of operations, with 2024/01/01 as the simulation start date. The portfolios are optimized using 100 days of historical data backward from the start date of each operation. Please note that it takes about 2 minutes to run the cell.

In the following cells, we plot the obtained operational history.

Appendix¶

Historical data of actual stock prices can be obtained as follows. Use pandas_datareader to retrieve the data downloaded from the database at Stooq. Please use it cautiously, as the number of API calls equals the number of stocks.

from pandas_datareader import data as web


def load_historical_data(tickers: list[str], start_date: datetime.date, end_date) -> pd.DataFrame:
    """Download historical data since start_date from Stooq"""
    history_df = pd.DataFrame()
    for idx, ticker in enumerate(tickers):
        ticker_df: pd.DataFrame = web.DataReader(ticker, "stooq", start_date, end_date)
        if len(ticker_df) == 0:
            print(f"failed to get {ticker} data")
            continue
        history_df = history_df.join(ticker_df["Close"].rename(ticker), how="outer")
        print("#", end="\n" if (idx + 1) % 20 == 0 else "")
    history_df.dropna(how="any", inplace=True) # Only keep days when all stocks were traded
    history_df.sort_index(inplace=True)
    return history_df

# Acquire stocks comprising the NASDAQ 100
tickers = ["ADBE", "ADP", "ABNB", "GOOGL", "GOOG", "AMZN", "AMD", "AEP", "AMGN", "ADI",
                     "ANSS", "AAPL", "AMAT", "ASML", "AZN", "TEAM", "ADSK", "BKR", "BIIB", "BKNG",
                     "AVGO", "CDNS", "CDW", "CHTR", "CTAS", "CSCO", "CCEP", "CTSH", "CMCSA", "CEG",
                     "CPRT", "CSGP", "COST", "CRWD", "CSX", "DDOG", "DXCM", "FANG", "DLTR", "DASH",
                     "EA", "EXC", "FAST", "FTNT", "GEHC", "GILD", "GFS", "HON", "IDXX", "ILMN",
                     "INTC", "INTU", "ISRG", "KDP", "KLAC", "KHC", "LRCX", "LIN", "LULU", "MAR",
                     "MRVL", "MELI", "META", "MCHP", "MU", "MSFT", "MRNA", "MDLZ", "MDB", "MNST",
                     "NFLX", "NVDA", "NXPI", "ORLY", "ODFL", "ON", "PCAR", "PANW", "PAYX", "PYPL",
                     "PDD", "PEP", "QCOM", "REGN", "ROP", "ROST", "SIRI", "SBUX", "SNPS", "TTWO",
                     "TMUS", "TSLA", "TXN", "TTD", "VRSK", "VRTX", "WBA", "WBD", "WDAY", "XEL", "ZS"]

df = load_historical_data(tickers, datetime.date(2023, 1, 1), datetime.date.today())