Overall Statistics |
Total Orders 5951 Average Win 0.14% Average Loss -0.15% Compounding Annual Return 3.734% Drawdown 32.800% Expectancy 0.209 Start Equity 100000 End Equity 246763.01 Net Profit 146.763% Sharpe Ratio 0.099 Sortino Ratio 0.092 Probabilistic Sharpe Ratio 0.000% Loss Rate 38% Win Rate 62% Profit-Loss Ratio 0.96 Alpha 0.018 Beta -0.097 Annual Standard Deviation 0.139 Annual Variance 0.019 Information Ratio -0.127 Tracking Error 0.223 Treynor Ratio -0.141 Total Fees $6034.43 Estimated Strategy Capacity $1600000000.00 Lowest Capacity Asset SPY R735QTJ8XC9X Portfolio Turnover 2.68% |
# region imports from AlgorithmImports import * import statistics # endregion class MeasuredYellowGreenLemur(QCAlgorithm): def initialize(self): # Set start date self.set_start_date(2000, 1, 1) # Set cash self.set_cash(100000) # List of stocks/ETFs list_of_tickers = ["SPY"] # SMA fast dictionary self.fast_dictionary = {} # SMA slow dictionary self.slow_dictionary = {} # create lists to store the raw forecast values self.raw_forecast_list_64 = [] self.raw_forecast_list_16 = [] self.scaled_forecast_list_16 = [] # Loop through list for ticker in list_of_tickers: # Register equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 4) # Get symbol symbol = equity.symbol # Create slow SMA EMA_object_slow = ExponentialMovingAverage(period = 256) # Create fast SMA EMA_object_fast = ExponentialMovingAverage(period = 64) # Store SMA slow self.slow_dictionary[symbol] = EMA_object_slow # Store SMA fast self.fast_dictionary[symbol] = EMA_object_fast # Register SMA for automatic update self.register_indicator(symbol, self.fast_dictionary[symbol]) # Register SMA for automatic update self.register_indicator(symbol, self.slow_dictionary[symbol]) # ---------------------------------------------------------------------------------------------- # Add another period length for smas to calculate forecasts # SMA fast dictionary self.fast_16_dictionary = {} # SMA slow dictionary self.slow_64_dictionary = {} # Loop through list for ticker in list_of_tickers: # Register equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 4) # Get symbol symbol = equity.symbol # Create slow SMA EMA_object_slow = ExponentialMovingAverage(period = 64) # Create fast SMA EMA_object_fast = ExponentialMovingAverage(period = 16) # Store SMA slow self.slow_64_dictionary[symbol] = EMA_object_slow # Store SMA fast self.fast_16_dictionary[symbol] = EMA_object_fast # Register SMA for automatic update self.register_indicator(symbol, self.fast_16_dictionary[symbol]) # Register SMA for automatic update self.register_indicator(symbol, self.slow_64_dictionary[symbol]) # ---------------------------------------------------------------------------------------------- # Add the standard deviation indicator to calculate the std of prices for each symbol # STD dictionary self.std_dictionary = {} # Loop through list for ticker in list_of_tickers: # Register equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 4) # Get symbol symbol = equity.symbol # Create standard dev object STD_object = StandardDeviation(35) # Store STD self.std_dictionary[symbol] = STD_object # Register SMA for automatic update self.register_indicator(symbol, self.std_dictionary[symbol]) def on_data(self, data: Slice): # List to store invested symbols invested_list = [] # Loop EMA dictionary for symbol in self.fast_dictionary: # If invested if self.portfolio[symbol].invested == True: # Add to invested list invested_list.append(symbol) # Get number of invested assets assets_invested = len(invested_list) # Get number of assets in algorithm assets_in_algorithm = len(self.fast_dictionary) # Get number of assets not invested not_invested = assets_in_algorithm - assets_invested # If not invested in all of the algorithm's assets if not_invested != 0: # Divide cash available by number of assets not invested capital = self.portfolio.cash / not_invested # If EMA fast and slow is ready if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True: # Loop EMA dictionary for symbol in self.fast_dictionary: # Get the standard deviation of price points risk_daily_price_points = self.std_dictionary[symbol].current.value if risk_daily_price_points != 0: # Calculate the normalised raw forecast for EWMA64 raw_forecast_64 = (self.fast_dictionary[symbol].current.value - self.slow_dictionary[symbol].current.value) / risk_daily_price_points # Calculate the absolute raw forecast to add it to the list absolute_raw_forecast = abs(raw_forecast_64) # Append the value to the list self.raw_forecast_list_64.append(absolute_raw_forecast) # Calculate the forecast scalar forecast_scalar = 10 / statistics.mean(self.raw_forecast_list_64) # Calculate the scaled forecast by multiplying the scalar by the raw forecast scaled_forecast_64 = raw_forecast_64 * 3.15 # Repeat the process for the EWMA16 raw_forecast_16 = (self.fast_16_dictionary[symbol].current.value - self.slow_64_dictionary[symbol].current.value) / risk_daily_price_points absolute_raw_forecast_16 = abs(raw_forecast_16) self.raw_forecast_list_16.append(absolute_raw_forecast_16) forecast_scalar_16 = 10 / statistics.mean(self.raw_forecast_list_16) scaled_forecast_16 = raw_forecast_16 * 8.91 absolute_scaled_forecast_16 = abs(scaled_forecast_16) self.scaled_forecast_list_16.append(absolute_scaled_forecast_16) mean_absolute_forecast = statistics.mean(self.scaled_forecast_list_16) # Combine the two forecasts by calculating the average combined_forecast = (scaled_forecast_64 + scaled_forecast_16) / 2 # If EMA fast and slow is ready if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True: # If not invested enter into the position based on the forecast if self.portfolio[symbol].invested == False: # Calculate quantity quantity = int((capital * combined_forecast / (self.securities[symbol].close * 10))) # Submit market order self.market_order(symbol = symbol, quantity = quantity) # If invested then adjust the position based on the forecast if self.portfolio[symbol].invested == True: # Calculate quantity quantity = int((self.portfolio.total_portfolio_value * combined_forecast / (self.securities[symbol].close * 10))) # calculate the qunatity based on the difference between the old quantity and the new quantity updated_quantity = quantity - self.portfolio[symbol].quantity # Submit market order self.market_order(symbol = symbol, quantity = updated_quantity) # Plot the combined forecast self.plot("combined_forecast", "forecast", combined_forecast) # Plot the quantity of position self.plot("mean_absolute_forecast", "mean_absolute_forecast", mean_absolute_forecast) # Plot the quantity of position self.plot("position", "position", self.portfolio[symbol].quantity)
# region imports from AlgorithmImports import * import statistics # endregion class MeasuredYellowGreenLemur(QCAlgorithm): def initialize(self): # Set start date self.set_start_date(2000, 1, 1) # Set cash self.set_cash(100000) # List of stocks/ETFs list_of_tickers = ["SPY","IWM","QQQ","EWA","ASEA","GLD"] # SMA fast dictionary self.fast_dictionary = {} # SMA slow dictionary self.slow_dictionary = {} # create lists to store the raw forecast values self.raw_forecast_list_64 = [] self.raw_forecast_list_16 = [] self.scaled_forecast_list_16 = [] # Loop through list for ticker in list_of_tickers: # Register equity = self.add_future(ticker = ticker, resolution = Resolution.Daily) # Get symbol symbol = equity.symbol # Create slow SMA EMA_object_slow = ExponentialMovingAverage(period = 256) # Create fast SMA EMA_object_fast = ExponentialMovingAverage(period = 64) # Store SMA slow self.slow_dictionary[symbol] = EMA_object_slow # Store SMA fast self.fast_dictionary[symbol] = EMA_object_fast # Register SMA for automatic update self.register_indicator(symbol, self.fast_dictionary[symbol]) # Register SMA for automatic update self.register_indicator(symbol, self.slow_dictionary[symbol]) # ---------------------------------------------------------------------------------------------- # Add another period length for smas to calculate forecasts # SMA fast dictionary self.fast_16_dictionary = {} # SMA slow dictionary self.slow_64_dictionary = {} # Loop through list for ticker in list_of_tickers: # Register equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily) # Get symbol symbol = equity.symbol # Create slow SMA EMA_object_slow = ExponentialMovingAverage(period = 64) # Create fast SMA EMA_object_fast = ExponentialMovingAverage(period = 16) # Store SMA slow self.slow_64_dictionary[symbol] = EMA_object_slow # Store SMA fast self.fast_16_dictionary[symbol] = EMA_object_fast # Register SMA for automatic update self.register_indicator(symbol, self.fast_16_dictionary[symbol]) # Register SMA for automatic update self.register_indicator(symbol, self.slow_64_dictionary[symbol]) # ---------------------------------------------------------------------------------------------- # Add the standard deviation indicator to calculate the std of prices for each symbol # STD dictionary self.std_dictionary = {} # Loop through list for ticker in list_of_tickers: # Register equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily) # Get symbol symbol = equity.symbol # Create standard dev object STD_object = StandardDeviation(35) # Store STD self.std_dictionary[symbol] = STD_object # Register SMA for automatic update self.register_indicator(symbol, self.std_dictionary[symbol]) def on_data(self, data: Slice): # List to store invested symbols invested_list = [] # Loop EMA dictionary for symbol in self.fast_dictionary: # If invested if self.portfolio[symbol].invested == True: # Add to invested list invested_list.append(symbol) # Get number of invested assets assets_invested = len(invested_list) # Get number of assets in algorithm assets_in_algorithm = len(self.fast_dictionary) # Get number of assets not invested not_invested = assets_in_algorithm - assets_invested # If not invested in all of the algorithm's assets if not_invested != 0: # Divide cash available by number of assets not invested capital = self.portfolio.cash / not_invested # If EMA fast and slow is ready if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True: # Loop EMA dictionary for symbol in self.fast_dictionary: # Get the standard deviation of price points risk_daily_price_points = self.std_dictionary[symbol].current.value if risk_daily_price_points != 0: # Calculate the normalised raw forecast for EWMA64 raw_forecast_64 = (self.fast_dictionary[symbol].current.value - self.slow_dictionary[symbol].current.value) / risk_daily_price_points # Calculate the absolute raw forecast to add it to the list absolute_raw_forecast = abs(raw_forecast_64) # Append the value to the list self.raw_forecast_list_64.append(absolute_raw_forecast) # Calculate the forecast scalar forecast_scalar = 10 / statistics.mean(self.raw_forecast_list_64) # Calculate the scaled forecast by multiplying the scalar by the raw forecast scaled_forecast_64 = raw_forecast_64 * 3.15 # Repeat the process for the EWMA16 raw_forecast_16 = (self.fast_16_dictionary[symbol].current.value - self.slow_64_dictionary[symbol].current.value) / risk_daily_price_points absolute_raw_forecast_16 = abs(raw_forecast_16) self.raw_forecast_list_16.append(absolute_raw_forecast_16) forecast_scalar_16 = 10 / statistics.mean(self.raw_forecast_list_16) scaled_forecast_16 = raw_forecast_16 * 8.91 absolute_scaled_forecast_16 = abs(scaled_forecast_16) self.scaled_forecast_list_16.append(absolute_scaled_forecast_16) mean_absolute_forecast = statistics.mean(self.scaled_forecast_list_16) # Combine the two forecasts by calculating the average combined_forecast = (scaled_forecast_64 + scaled_forecast_16) / 2 # If EMA fast and slow is ready if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True: # If not invested enter into the position based on the forecast if self.portfolio[symbol].invested == False: # Calculate quantity quantity = int((capital * combined_forecast / (self.securities[symbol].close * 10))) # Submit market order self.market_order(symbol = symbol, quantity = quantity) # If invested then adjust the position based on the forecast if self.portfolio[symbol].invested == True: # Calculate quantity quantity = int((self.portfolio.total_portfolio_value * combined_forecast / (self.securities[symbol].close * 10))) # calculate the qunatity based on the difference between the old quantity and the new quantity updated_quantity = quantity - self.portfolio[symbol].quantity # Submit market order self.market_order(symbol = symbol, quantity = updated_quantity) # Plot the combined forecast self.plot("combined_forecast", "forecast", combined_forecast) # Plot the quantity of position self.plot("forecast_scalar_16", "forecast_scalar_16", forecast_scalar_16) # Plot the quantity of position self.plot("position", "position", self.portfolio[symbol].quantity)
# region imports from AlgorithmImports import * # endregion class MeasuredYellowGreenLemur(QCAlgorithm): def initialize(self): # Set start date self.set_start_date(2001, 1, 1) # Set cash self.set_cash(100000) # List of stocks/ETFs list_of_tickers = ["SPY","IWM","QQQ","EWA","ASEA","GLD","SLV","USO","WEAT","CORN","PLTM","GBTC","FXE","FXY","EWO","CPER","SOYB","BNO","UGA"] # SMA fast dictionary self.fast_dictionary = {} # SMA slow dictionary self.slow_dictionary = {} # Loop through list for ticker in list_of_tickers: # Register equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 8) # Get symbol symbol = equity.symbol # Create slow SMA EMA_object_slow = ExponentialMovingAverage(period = 128) # Create fast SMA EMA_object_fast = ExponentialMovingAverage(period = 32) # Store SMA slow self.slow_dictionary[symbol] = EMA_object_slow # Store SMA fast self.fast_dictionary[symbol] = EMA_object_fast # Register SMA for automatic update self.register_indicator(symbol, self.fast_dictionary[symbol]) # Register SMA for automatic update self.register_indicator(symbol, self.slow_dictionary[symbol]) def on_data(self, data: Slice): # List to store invested symbols invested_list = [] # Loop MACD dictionary for symbol in self.fast_dictionary: # If invested if self.portfolio[symbol].invested == True: # Add to invested list invested_list.append(symbol) # Get number of invested assets assets_invested = len(invested_list) # Get number of assets in algorithm assets_in_algorithm = len(self.fast_dictionary) # Get number of assets not invested not_invested = assets_in_algorithm - assets_invested # If not invested in all of the algorithm's assets if not_invested != 0: # Divide cash available by number of assets not invested cash_to_invest_in_each_additional_asset = self.portfolio.cash / not_invested # Loop EMA dictionary for symbol in self.fast_dictionary: # If EMA fast and slow is ready if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True: # If EMA fast is greater than EMA slow go long if self.fast_dictionary[symbol].current.value > self.slow_dictionary[symbol].current.value: # If not invested if self.portfolio[symbol].invested == False: # Calculate quantity quantity = (int(cash_to_invest_in_each_additional_asset / self.securities[symbol].close)) * 8 # Submit market order self.market_order(symbol = symbol, quantity = quantity) # If EMA fast is less than EMA slow then exit elif self.fast_dictionary[symbol].current.value < self.slow_dictionary[symbol].current.value: # If invested if self.portfolio[symbol].invested == True: # Submit market order self.market_order(symbol = symbol, quantity = -self.portfolio[symbol].quantity)