Currently, the algorithms for constant-rebalanced and MPT are in scripts, which makes reusing and maintaining difficult.

It would be good to refactor them into classes, inheriting from a base Algorithm class.

This could be used as features for global market prediction model or directly as a trading signal

After trying a few days trying install this in a docker container, it has become apparent to me that all the dependencies are broken and this library cannot be installed anymore. Either the python version won't match or numpy won't compile (among a plethora of other problems). Don't loose your time.

Hi, I managed to start the frontend...just want to know how to update stock prices ?? (got a bit stuck running the backend jupyter notebook with "no bundle registered with the name 'robo-advisor'")...not sure if it is because Quantopian has closed door and zipline got tookover. Thanks

Even though the weights are over zero, cash amount is still at maximum for some time.
Likely that there is some calculation error or offset

In some cases, the ticker might not exist for certain periods, eg one of the tickers is not listed yet.
This will cause error in the algorithms because it tries to perform means-variance optimisation on an empty history vector. Similarly for constant-rebalancing, it will attempt to allocate shares to a stock that does not yet exist!

Stocks that do not exist on the "current" date, should be filtered away before performing means-variance optimisation and constant-rebalancing.

Weights for constant-rebalancing should also be automatically adjusted/normalised. For example, consider a portfolio of 4 assets, with the following weights- A: 0.25, B: 0.25, C: 0.25, D: 0.25. If C does not exist, then weights should be automatically redistributed to A:0.33, B:0.33, D:0.33

We will attempt to improve traditional portfolio optimisation techniques by utilising sentiments. The traditional techniques that we will consider are

• Constant Rebalancing based on fixed ratios
• Modern Portfolio Theory (MPT)
• Hierarchical Risk Parity (HRP)

See all transactions made in a user's account such as how much was invested in which portfolio

Create enviroment.yml so that the environment can be easily created
Follow instructions in Conda

Then it would be easy to install the dependencies by creating the Conda environment roboadvisor from the given environment.yml file and activating it like so:

conda env create -f environment.yml
conda activate roboadvisor

For the front-end, instead of always retrieving the last closed stock prices for all the tickers, we should cache them for better performance. So that only the first request per day needs to be done!

Since there are many possibilities of stocks and start and end date, we need to also consider a unique identifier for our cache file, maybe using MD5

Front-end for robo-advisor

• Basic user management - Sign up and log in
• Summary page showing current account balance, earnings, portfolio asset value etc
• Add and withdraw funds (virtual funds, no actual interface with real money)
• Quick method to reset account if necessary
• Portfolio Management
  • View different portfolios
  • Buy and Sell selected portfolio
  • Calculate asset distribution in portfolio and number of shares to buy
  • Display current value of portfolio by retrieving latest prices
  • View details of a selected portfolio such as backtesting details, and comparison with relevant benchmarks
• Recommend portfolio based on risk-assessment

Since this is a demo system with only paper trading, we will only consider the following:
reset of account - go to the http://localhost:8000/portfolio/reset/1
add/withdraw of cash - go to http://localhost:8000/portfolio/ and select Add/Withdraw Funds.
buy/sell portfolios - go to http://localhost:8000/portfolio/edit/, select the relevant portfolio to buy/sell.

Current markowitz algorithm is taken from Quantopian. However, it will only optimize for maximal Sharpe ratio.

We should add the following optimisation objectives as well: Minimal volatility, maximum Sharpe for a given target risk, maximum Sharpe for a given target return, etc

This seems to be found in the library PyPortfolioOpt, so maybe we can just switch to call this library and adapt the existing code. Example usage for this library is also captured by mayabenowitz

Out of the box, there is no progress indicators for Genetic Algorithm (GA) when using DEAP.

To add progress bar using tqdm
To add plot of statistics of population to see if values are converging

See the following articles for some ideas

• https://www.tandfonline.com/doi/abs/10.1080/0015198X.2019.1596678?journalCode=ufaj20
• https://www.cfainstitute.org/research/financial-analysts-journal/2019/ip-machine-learning-for-stock-selection
• https://www.linkedin.com/pulse/portfolio-selection-graph-algorithms-deep-learning-maya-benowitz/

We will need to

• create script to allow downloading of historical data from Yahoo or similar, and registering and ingesting of custom data bundle
• run zipline algorithm for backtesting within Python code, instead of at command line. This will allow us to invoke backtesting in Django later on more easily (using https://github.com/alpacahq/roboadvisor as a starting point but remove dependency on alpaca dataset)
• apply Modern Portfolio Theory to a given basket of assets
• add visualisation of backtest similar to Quantopian's
• compare its output (performance stats such as Sharpe ratio, cumulative returns, max drawdown) with that from Quantopian to verify that results are the same/similar.

For more realistic trades, commission model needs to be added.
Need to add commission models that are appropriate for the market that the 'universe' is based in

Even though there are no outstanding migrations, django fails in debug mode

• Research on possible algorithms
  • Examples:
    • Deep Recurrent Factor model using LSTM with LRP by K Nakagawa - ‎2019
• Implement some of the algorithms