Can Kalman Filters Improve Your Trading Signals

# --- Inside KalmanFilterTrendWithTrail class ---
    params = (
        # Parameters passed to the Kalman Filter Indicator
        ('process_noise', 1e-5),    # Filter parameter: Assumed noise in the price model (Q)
        ('measurement_noise', 1e-1),# Filter parameter: Assumed noise in the price data (R)

        # Strategy-specific parameter
        ('trail_percent', 0.05),    # Trailing stop loss percentage (e.g., 0.05 = 5%)
        ('printlog', True),         # Enable logging output
    )

# --- Inside KalmanFilterTrendWithTrail class ---
    def __init__(self):
        # Instantiate the Kalman Filter Indicator, passing relevant parameters
        self.kf = KalmanFilterIndicator(
            process_noise=self.p.process_noise,
            measurement_noise=self.p.measurement_noise
        )

        # Create convenient references to the indicator's output lines
        self.kf_price = self.kf.lines.kf_price
        self.kf_velocity = self.kf.lines.kf_velocity

        # Initialize order trackers
        self.order = None # Tracks pending entry orders
        self.stop_order = None # Tracks pending stop orders

        if self.params.printlog:
            # Log the parameters being used
            print(f"Strategy Parameters: Process Noise={self.params.process_noise}, "
                  f"Measurement Noise={self.params.measurement_noise}, "
                  f"Trail Percent={self.params.trail_percent * 100:.2f}%")

# --- Inside KalmanFilterTrendWithTrail class ---
    def next(self):
        # If an entry order is pending, do nothing
        if self.order:
            return

        # Get the estimated velocity from the indicator
        # Need to check length because indicator might need warmup
        if len(self.kf_velocity) == 0:
             return # Indicator not ready yet

        estimated_velocity = self.kf_velocity[0]
        current_position_size = self.position.size
        current_close = self.data.close[0] # For logging

        # --- Trading Logic ---
        # Only evaluate entries if FLAT
        if current_position_size == 0:
            if self.stop_order: # Safety check - cancel any stray stop orders if flat
                self.log("Warning: Position flat but stop order exists. Cancelling.", doprint=True)
                self.cancel(self.stop_order)
                self.stop_order = None

            # --- Entry Signal Check ---
            if estimated_velocity > 0:
                 # Positive velocity -> Go Long
                 self.log(f'BUY CREATE (KF Vel > 0), Close={current_close:.2f}, KF Vel={estimated_velocity:.4f}', doprint=True)
                 self.order = self.buy() # Place buy order and track it
            elif estimated_velocity < 0:
                 # Negative velocity -> Go Short
                 self.log(f'SELL CREATE (KF Vel < 0 - Short Entry), Close={current_close:.2f}, KF Vel={estimated_velocity:.4f}', doprint=True)
                 self.order = self.sell() # Place sell order and track it
        else:
             # If already in a position, do nothing here.
             # The trailing stop placed via notify_order handles the exit.
             pass

# --- Inside KalmanFilterTrendWithTrail class ---
    def notify_order(self, order):
        # (Initial checks for Submitted/Accepted status omitted for brevity)
        ...
        if order.status == order.Completed:
            # Check if it's the ENTRY order we were waiting for
            if self.order and order.ref == self.order.ref:
                entry_type = "BUY" if order.isbuy() else "SELL"
                exit_func = self.sell if order.isbuy() else self.buy # Determine exit order type

                # Log entry execution (code omitted for brevity)
                ...

                # Place the TRAILING STOP order if trail_percent is valid
                if self.p.trail_percent and self.p.trail_percent > 0.0:
                    self.stop_order = exit_func(exectype=bt.Order.StopTrail,
                                                trailpercent=self.p.trail_percent)
                    self.log(f'Trailing Stop Placed for {entry_type} order ref {self.stop_order.ref} at {self.p.trail_percent * 100:.2f}% trail', doprint=True)
                else:
                     self.log(f'No Trailing Stop Placed (trail_percent={self.p.trail_percent})', doprint=True)

                self.order = None # Reset entry order tracker

            # Check if it's the STOP order that completed
            elif self.stop_order and order.ref == self.stop_order.ref:
                # Log stop execution (code omitted for brevity)
                ...
                self.stop_order = None # Reset stop order tracker
                self.order = None # Reset entry tracker too
        # Handle Failed orders (code omitted for brevity)
        ...