Indicator with consolidator warmup inconsistency

I also adjust the indicator's built in window size and try to see if historical values matches after warmup. It turns out that for the entire rolling window,  all warm-up values dont match.

Here’s what’s wrong in your code, and why you see the initial mismatch between your manual and automatic RSI:

Bugs and Logic Issue

• You prime your manual RSI by pushing historical bars through the consolidator before live trading begins.
• Then, you also explicitly call self.warm_up_indicator(self.spy, self.rsi_auto_warmup, self.resolution) for the automatic RSI. But this warms up the auto RSI after history has already been pushed through the consolidator, meaning it’s essentially been warmed twice (once in setup, then again with warm_up_indicator).
• The bars and sample order in which the two RSI indicators get data will not always perfectly match. So your first matching sample will be offset by one bar.

How to Fix

• Don’t use both approaches at the same time. To ensure both RSIs are primed from the exact same bars, only warm them in one place/step.
• In practice: For the cleanest match, remove the call to self.warm_up_indicator() entirely, and just prime both RSI indicators by updating only through the consolidator loop over history. Like this, both construct their internal buffer from the identical sequence and count of bars, so their state will always match.

Here is the revised workflow:

class IndicatorDisrepancy(QCAlgorithm):
    def initialize(self):
        self.set_cash(100000)
        self.set_start_date(2024, 10, 1)
        self.set_end_date(2024, 10, 31)
        self.resolution = Resolution.DAILY
        self.spy = self.add_equity("SPY", self.resolution).symbol

        # Manual RSI
        self.rsi_manual_warmup = RelativeStrengthIndex(14, MovingAverageType.SIMPLE)
        # Auto RSI
        self.rsi_auto_warmup = self.rsi(self.spy, 14, MovingAverageType.SIMPLE, self.resolution)
        self.ready = False

    def on_data_consolidated(self, sender, bar):
        self.rsi_manual_warmup.update(bar)
        if not self.ready:
            return
        for i in [0, 1]:
            manual_value = self.rsi_manual_warmup[i].value
            auto_value = self.rsi_auto_warmup[i].value
            if abs(manual_value - auto_value) > 0.01:
                self.error(f"idx={i} Manual: {manual_value:.4f} Auto: {auto_value:.4f} do not match after ready for bar at {bar.time}-{bar.end_time}")

    def on_data(self, data: Slice):
        if self.ready:
            return
        assert self.spy in data

        history = self.history[TradeBar](
            self.spy, periods=50, resolution=self.resolution
        )
        self.consolidator = TradeBarConsolidator(timedelta(days=1))
        self.consolidator.data_consolidated += self.on_data_consolidated
        self.subscription_manager.add_consolidator(self.spy, self.consolidator)

        # Feed historical bars through consolidator (this will update manual RSI and also prime the automatic RSI via QC's internal flow)
        for bar in history:
            self.consolidator.update(bar)

        # REMOVE this line: self.warm_up_indicator(self.spy, self.rsi_auto_warmup, self.resolution)
        # Both RSIs now receive exactly the same initial data in exactly the same way.

        self.ready = True

Summary:

• Don’t use both a consolidator history feed and warm_up_indicator for the same automatic indicator.
• Feed both indicators using only one approach to guarantee exact alignment.
• This will make your first “live” day’s values match perfectly.

Let me know if you want the version that instead uses only warm_up_indicator for both, or if you want to see added logs/checks for indicator readiness!

Sources: Automatic Indicators - QuantConnect.com, Stochastic Indicator Warms Up Properly Regression Algorithm, Indicator Warmup Algorithm, Manual Indicators - QuantConnect.com, Consolidate Hour Bars Into Daily Bars Regression Algorithm

When you use a custom window size (e.g., indicator.window = 5) on an indicator like RSI, it's critical that both your manual and automatic RSI indicators are "warmed up" with exactly the same sequence and number of bars. If you warm them up differently—such as using warm_up_indicator for the automatic RSI and manual history+consolidator updates for the manual RSI—they will usually NOT match within the contents of their internal rolling window, even after warmup.

Why this mismatch happens:

• Each warming method (manual with history, versus automatic with warm_up_indicator) might feed a different set of data or use a different sequence of historical data bars. Sometimes, the amount of data or the order in which it's fed creates an offset or misalignment between the two RollingWindows.
• The indicator's rolling window holds the most recent window values. If the priming process is not absolutely identical (in terms of both data bars and update sequence), the windows will naturally diverge. That means the values for all indices ([0], [1], ..., [window-1]) will show a mismatch after warmup (until enough new live bars have arrived to "flush out" the window with new matching data).

How to guarantee matching RollingWindows after warmup:

1. Warm both indicators using the same data in the same order, and update them in parallel in your priming loop.
2. Do not use both warm_up_indicator and a manual history update at the same time.
3. Request a number of historical bars sufficient to fill both the indicator period AND the RollingWindow size (for example, for RSI(14) with window=5, request at least 14+5+some buffer bars).

Corrected Example: Here’s how you can precisely synchronize the rolling window for both manual and "automatic" RSI by manually updating both from the same history:

class RollingWindowRSIExample(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)
        symbol = self.add_equity("SPY", Resolution.DAILY).symbol

        self.rsi_manual = RelativeStrengthIndex(14, MovingAverageType.SIMPLE)
        self.rsi_manual.window_size = 5

        self.rsi_auto = RelativeStrengthIndex(14, MovingAverageType.SIMPLE)
        self.rsi_auto.window_size = 5

        # Update both from the same consolidator for on-going live data
        self.consolidator = TradeBarConsolidator(timedelta(days=1))
        self.consolidator.data_consolidated += self.on_bar_consolidated
        self.subscription_manager.add_consolidator(symbol, self.consolidator)

        # Manually prime BOTH indicators from history, identically
        history_bars = 40
        history = self.history(symbol, history_bars, Resolution.DAILY)
        if not history.empty:
            if isinstance(history.index, pd.MultiIndex):
                history = history.xs(symbol)
            for time, row in history.iterrows():
                if isinstance(time, pd.Timestamp):
                    time = time.to_pydatetime()
                bar = TradeBar(time, symbol, row["open"], row["high"], row["low"], row["close"], row["volume"], timedelta(days=1))
                # Update both indicators with exactly the same sequence
                self.rsi_manual.update(bar)
                self.rsi_auto.update(bar)

    def on_bar_consolidated(self, sender, bar):
        self.rsi_manual.update(bar)
        self.rsi_auto.update(bar)

    def on_data(self, slice: Slice) -> None:
        if not self.rsi_manual.is_ready or not self.rsi_auto.is_ready:
            return
        for i in range(self.rsi_manual.window.count):
            manual_value = self.rsi_manual.window[i]
            auto_value = self.rsi_auto.window[i]
            if abs(manual_value - auto_value) > 1e-6:
                self.error(
                    f"RollingWindow idx={i} Manual: {manual_value:.4f} Auto: {auto_value:.4f} do not match"
                )

Key points:

• DO NOT use warm_up_indicator or set_warmup() when manually priming in this fashion.
• Prime both indicators together, using only one unified method.
• Once all new values arrive live, the rolling windows will always remain in sync.

Let me know if you want further illustration or a logging/debugging helper for this!

Sources: Automatic Indicators - QuantConnect.com, Manual Indicators - QuantConnect.com, Warm Up Periods - QuantConnect.com, Indicator Warmup Algorithm, Stochastic Indicator Warms Up Properly Regression Algorithm

But this warms up the auto RSI after history has already been pushed through the consolidator, meaning it’s essentially been warmed twice (once in setup, then again with warm_up_indicator).

But in my code warm_up_indicator warms up my auto-RSI, and consolidator warms up my manual RSI. so each indicator is only warmed up once.