How to get this strategy running?

How are you trying to get the symbol and what symbol?

Here is one example in python

bill = Symbol.Create("BILL", SecurityType.Equity, Market.USA)
 

Here is my strategy code. Unfortunately platform doesn't allow attached backtest that failed with errors.

#region imports
from AlgorithmImports import *
#endregion
# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2020 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import numpy as np
import pandas as pd
import scipy as sp
import statsmodels.api as smapi
from scipy.sparse.csgraph import connected_components
from sklearn.covariance import EmpiricalCovariance as EC
import pywt

class OptimizedUncoupledRegulators(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2017, 9, 20)  # Set Start Date
        self.SetCash(100000)  # Set Strategy Cash
        
        period = 250
        
        self.SetBrokerageModel(AlphaStreamsBrokerageModel())
        self.SetPortfolioConstruction(InsightWeightingPortfolioConstructionModel(lambda time: None))
        self.SetAlpha(EntropyAlphaModel(period))
        filter_function = lambda constituents: [x.Symbol for x in constituents]
        universe = self.Universe.ETF("SPY", Market.USA, self.UniverseSettings, filter_function)
        self.AddUniverse(universe)
        self.AddEquity('SPY', Resolution.Daily)

        
class EntropyAlphaModel(AlphaModel):
    def __init__(self, period):
        self.period = period
        self.closes = {}
        
    def Update(self, algorithm, data):
        K = 0
        for symbol, closes in self.closes.items():
            K = len(list(closes))
            if data.Bars.ContainsKey(symbol):
                closes.Add(data[symbol].Close)
                K = len(list(closes))
                
        insights = []
        weights = []
        
        C = np.zeros((K, len(self.closes)))
        breakAlgo = False
        ii = 0
        for symbol, closes in self.closes.items():
            if symbol != 'SPY':
                close = np.asarray(list(closes))[::-1]
                if close.shape[0] < 250 or K < 250:
                    breakAlgo = True
                    break
                C[:, ii] = close
                ii += 1
        
        if breakAlgo:
            return insights

        C = np.nan_to_num(np.diff(np.log(C), axis=0))

        lags=[90, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30]

        entropies = []
        for lag in lags:
            entropies.append(self.CalcEntropy(C[-lag:, :]))

        entropies = pd.Series(np.asarray(entropies)).dropna()
        entropy_indicator = entropies.iloc[-1] - entropies.ewm(span=5).mean().iloc[-1]

        if entropy_indicator > 0:
            insightDirection = InsightDirection.Down
        elif entropy_indicator < 0:
            insightDirection = InsightDirection.Up
        else:
            insightDirection = InsightDirection.Flat
        
        insights.append(Insight.Price("SPY", timedelta(1), insightDirection, None, None, None, 0.9))
        return insights
  
    def OnSecuritiesChanged(self, algorithm, changed):
        for security in changed.AddedSecurities:
            symbol = security.Symbol
            self.closes[symbol] = RollingWindow[float](self.period)
                
            hist_data = algorithm.History(symbol, self.period, Resolution.Daily).loc[symbol]
            for _, row in hist_data.iterrows():
                self.closes[symbol].Add(row['close'])
        
        for security in changed.RemovedSecurities:
            if security.Symbol in self.closes:
                self.closes.pop(security.Symbol)

    def CalcEntropy(self, R):
        C = EC().fit(R).covariance_
        d = np.sqrt(C.diagonal())
        C = ((C.T/d).T)/d
        C = (np.abs(C)>0.6).astype(int)
        _, labels = connected_components(C)
        counts = np.unique(labels, return_counts=True)[1]
        probs = counts / np.sum(counts)
        entropy = 0.0
        if len(counts) > 1:
            entropy = sp.stats.entropy(probs) / np.log(len(counts))
        return entropy

It takes quite a while to run, but I would change history code like this for performance:

        symbols = [x.Symbol for x in changed.AddedSecurities]
        history = algorithm.History(symbols, self.period, Resolution.Daily)
        for security in changed.AddedSecurities:
            symbol = security.Symbol
            self.closes[symbol] = RollingWindow[float](self.period)

            hist_data = history.loc[symbol]
            for _, row in hist_data.iterrows():
                self.closes[symbol].Add(row['close'])

also, this condition in line 63 will not work how expected, because keys are or type Symbol, not str:

            if symbol != 'SPY':

instead you should either do it like this:

if symbol.Value != 'SPY':

or in Initialize save spy symbol like this:

        self.spy = self.AddEquity('SPY', Resolution.Daily).Symbol

and then compare like this:

            if symbol != self.spy:

Perhaps this is what is causing the exception later in the code.