from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np
from pypfopt.efficient_frontier import EfficientFrontier
from pypfopt import risk_models
from pypfopt import expected_returns

class AlphaFiveUSTreasuries(QCAlgorithm):

def Initialize(self):

#1. Required: Five years of backtest history
self.SetStartDate(2001, 1, 1)

#2. Required: Alpha Streams Models:
self.SetBrokerageModel(BrokerageName.AlphaStreams)

#3. Required: Significant AUM Capacity
self.SetCash(100000)

self.UniverseSettings.Resolution = Resolution.Daily
self.AddUniverse(self.CoarseUniverseSelection)

self.AddEquity("SPY",Resolution.Daily)

#4. Required: Benchmark to SPY
self.SetBenchmark("SPY")

self.SetPortfolioConstruction(InsightWeightingPortfolioConstructionModel())
self.SetExecution(ImmediateExecutionModel())

self.assets = []

self.symbols = {}

self.portfolioValue = RollingWindow[Decimal](500)

self.SetWarmup(500)

# initializing security with last known price
# self.SetSecurityInitializer(lambda x: x.SetMarketPrice(self.GetLastKnownPrice(x)))

# fine tune how frequent training is to obtain best results
# self.Schedule.On(self.DateRules.Every(DayOfWeek.Monday), self.TimeRules.AfterMarketOpen("SPY", 30), self.EveryDayAfterMarketOpen)
# self.Schedule.On(self.DateRules.MonthEnd(), self.TimeRules.AfterMarketOpen("SPY",0), self.EveryMonthAfterMarketClose)

# Portfolio Optimization using Mean-Variance
# def OptimalPortfolio(self, coarse):
# pass


def CoarseUniverseSelection(self, coarse):
# if self.lastMonth == algorithm.Time.month:
# return Universe.Unchanged
# self.lastMonth = algorithm.Time.month

# if self.IsWarmingUp:
# return

sortedByDollarVolume = sorted([x for x in coarse if x.HasFundamentalData], key=lambda x: x.DollarVolume, reverse=True)

self.Debug(f"test going in sort dollar volume")

for i in range(10):
if len(self.assets) <10 and sortedByDollarVolume[i] not in self.assets:
self.assets.append(sortedByDollarVolume[i].Symbol)

self.df = pd.DataFrame()

# if self.df.iloc[0:,1].count() == 252:
# self.assets.append()

# for i in range(len(self.assets)):
# self.symbols[self.assets[i]] = self.AddEquity( self.assets[i] ,Resolution.Hour)

for x in range(len(self.assets)):
self.AddEquity( self.assets[x] ,Resolution.Daily)

# for asset in self.assets, count column less than 252 then drop
self.df = self.History(self.assets, 252)

# check if historical data 252 days available in asset
self.df = self.df["close"].unstack(level=0)

weights = np.array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

self.returns = self.df.pct_change()

# show annualized covariance matrix
self.cov_matrix_annual = self.returns.cov() * 252

# self.Debug(self.cov_matrix_annual.iloc[:,1])

# calculate portfolio variance
self.port_variance = np.dot(weights.T, np.dot(self.cov_matrix_annual, weights))

# calculate portfolio volatility
self.port_volatility = np.sqrt(self.port_variance)

# self.Debug(f"returns mean")
# self.Debug(self.returns.mean())

# Calculate annual portfolio return
self.portfolioSimpleAnnualReturn = np.sum(self.returns.mean() * weights) * 252

# show expected annual return, volatility (risk), variance
self.percent_var = str(round(self.port_variance, 2) * 100) + '%'
self.percent_vols = str(round(self.port_volatility, 2) * 100) + '%'
self.percent_ret = str(round(self.portfolioSimpleAnnualReturn, 2) * 100) + '%'

self.Debug(f'Expected annual return: ')
self.Debug(self.percent_ret)

self.Debug('Annual volatility / risk: ')
self.Debug(self.percent_vols)

self.Debug('Annual variance: ')
self.Debug(self.percent_var)

# Portfolio Optimization

# Calulate the expected returns and annualized sample covariance matrix of asset returns
self.mu = expected_returns.mean_historical_return(self.df)

self.S = risk_models.sample_cov(self.df)

self.ef = EfficientFrontier(self.mu, self.S)

self.weights = (self.ef).max_sharpe()

self.cleaned_weights = self.ef.clean_weights()

self.cleaned_weights = [round(float(x), 2) for x in self.cleaned_weights.values()]

# fix cleaned weights
# self.Debug(f"show updated weights")
self.Debug(self.cleaned_weights)

# self.Debug(self.ef.portfolio_performance(verbose = True))

return [Symbol.Create(x, SecurityType.Equity, Market.USA) for x in self.symbols.values()]

Hi guys, I'm currently trying to implement mean-variance portfolio optimization in QuantConnect. However, I realised that there is a problem with my annual returns. It starts off positive and ends up being negative. 

The algorithm also crashes after running for a while and the following runtime error will be displayed "Runtime Error: OptimizationError : Please check your objectives/constraints or use a different solver.at CoarseUniverseSelection in main.py:line 130 :: self.weights = (self.ef).max_sharpe()".

Any help is appreciated, thank you!