修正未成交模型持仓生命周期

2026-07-17 13:26:57 +08:00
parent 0337cc8a22
commit 5918a03456
2 changed files with 284 additions and 9 deletions
@@ -1417,19 +1417,28 @@ impl PlatformExprStrategy {
        self.intraday_execution_start_time()
    }

+    fn uses_persistent_model_lifecycle(&self) -> bool {
+        self.config.hold_until_exit_enabled
+            && self.config.stop_take_reference_price_mode
+                == PlatformStopTakeReferencePriceMode::SignalDayPostAdjustedClose
+    }
+
    fn sync_position_entry_dates(&mut self, portfolio: &PortfolioState, signal_date: NaiveDate) {
+        let persistent_model_lifecycle = self.uses_persistent_model_lifecycle();
        let is_held = |symbol: &str| {
            portfolio
                .position(symbol)
                .map(|position| position.quantity > 0)
                .unwrap_or(false)
        };
-        self.position_entry_dates
-            .retain(|symbol, _| is_held(symbol));
-        self.position_holding_days
-            .retain(|symbol, _| is_held(symbol));
-        self.position_holding_days_last_counted
-            .retain(|symbol, _| is_held(symbol));
+        if !persistent_model_lifecycle {
+            self.position_entry_dates
+                .retain(|symbol, _| is_held(symbol));
+            self.position_holding_days
+                .retain(|symbol, _| is_held(symbol));
+            self.position_holding_days_last_counted
+                .retain(|symbol, _| is_held(symbol));
+        }
        for position in portfolio.positions().values() {
            if position.quantity == 0 {
                continue;
@@ -1438,6 +1447,28 @@ impl PlatformExprStrategy {
            self.position_entry_dates
                .entry(symbol.clone())
                .or_insert(signal_date);
+            self.position_holding_days
+                .entry(symbol.clone())
+                .or_insert(0);
+            self.position_holding_days_last_counted
+                .entry(symbol)
+                .or_insert(signal_date);
+        }
+
+        let lifecycle_symbols = if persistent_model_lifecycle {
+            self.position_entry_dates
+                .keys()
+                .cloned()
+                .collect::<Vec<_>>()
+        } else {
+            portfolio
+                .positions()
+                .values()
+                .filter(|position| position.quantity > 0)
+                .map(|position| position.symbol.clone())
+                .collect::<Vec<_>>()
+        };
+        for symbol in lifecycle_symbols {
            let holding_days = self
                .position_holding_days
                .entry(symbol.clone())
@@ -7125,6 +7156,34 @@ impl PlatformExprStrategy {
                symbols.insert(position.symbol.clone());
            }
        }
+        if self.uses_persistent_model_lifecycle() {
+            for (symbol, entry_date) in &self.position_entry_dates {
+                if ctx
+                    .portfolio
+                    .position(symbol)
+                    .is_some_and(|position| position.quantity > 0)
+                {
+                    continue;
+                }
+                let entry_price = ctx
+                    .data
+                    .market_latest_back_adjusted_close(*entry_date, symbol)
+                    .ok_or_else(|| {
+                        BacktestError::Data(crate::data::DataSetError::MissingSnapshot {
+                            kind: "model admission post-adjusted close",
+                            date: *entry_date,
+                            symbol: symbol.clone(),
+                        })
+                    })?;
+                let mut model_position = crate::portfolio::Position::new(symbol.clone());
+                model_position.buy(*entry_date, 1, entry_price);
+                let (stop_hit, profit_hit) =
+                    self.stop_take_action_for_position(ctx, signal_date, day, &model_position)?;
+                if stop_hit || profit_hit {
+                    symbols.insert(symbol.clone());
+                }
+            }
+        }
        Ok(symbols)
    }

@@ -8937,6 +8996,32 @@ impl Strategy for PlatformExprStrategy {
        let day = self.day_state(ctx, decision_date)?;
        let current_stop_take_exit_symbols =
            self.current_stop_take_exit_symbols(ctx, signal_date, &day)?;
+        let mut model_only_lifecycle_exit_symbols = current_stop_take_exit_symbols
+            .iter()
+            .filter(|symbol| {
+                !ctx.portfolio
+                    .position(symbol)
+                    .is_some_and(|position| position.quantity > 0)
+            })
+            .cloned()
+            .collect::<BTreeSet<_>>();
+        if self.uses_persistent_model_lifecycle() {
+            for symbol in self.position_entry_dates.keys() {
+                if ctx
+                    .portfolio
+                    .position(symbol)
+                    .is_some_and(|position| position.quantity > 0)
+                {
+                    continue;
+                }
+                if self.max_holding_days_exceeded(symbol).is_some() {
+                    model_only_lifecycle_exit_symbols.insert(symbol.clone());
+                }
+            }
+            for symbol in &model_only_lifecycle_exit_symbols {
+                self.forget_position_entry_date(symbol);
+            }
+        }
        let (selection_market_date, selection_universe_factor_date, selection_factor_date) =
            self.selection_dates(ctx);
        let (explicit_action_intents, mut explicit_action_diagnostics) = if !in_skip_window
@@ -9001,12 +9086,15 @@ impl Strategy for PlatformExprStrategy {
            )?;
            selection_notes = notes;
            risk_decisions = selection_risk_decisions;
-            let held_symbols = ctx
+            let mut held_symbols = ctx
                .portfolio
                .positions()
                .keys()
                .cloned()
                .collect::<BTreeSet<_>>();
+            if self.uses_persistent_model_lifecycle() {
+                held_symbols.extend(self.position_entry_dates.keys().cloned());
+            }
            let selected = Self::buffered_selection(
                &ranked_stock_list,
                &held_symbols,
@@ -9069,7 +9157,7 @@ impl Strategy for PlatformExprStrategy {
            .unwrap_or(false);
        let mut daily_top_up_debug_notes = Vec::<String>::new();
        let mut projection_debug_notes = Vec::<String>::new();
-        let mut exit_symbols = BTreeSet::new();
+        let mut exit_symbols = model_only_lifecycle_exit_symbols;
        let mut same_day_sold_symbols = BTreeSet::<String>::new();
        let mut intraday_attempted_buys = BTreeSet::<String>::new();
        let mut same_bar_buy_symbols = BTreeSet::<String>::new();
@@ -9234,6 +9322,16 @@ impl Strategy for PlatformExprStrategy {
                });
                self.forget_position_entry_date(symbol);
            }
+            if self.uses_persistent_model_lifecycle() {
+                let model_symbols = self
+                    .position_entry_dates
+                    .keys()
+                    .cloned()
+                    .collect::<Vec<_>>();
+                for symbol in model_symbols {
+                    self.forget_position_entry_date(&symbol);
+                }
+            }
            let mut notes = vec![format!("seasonal stop window on {}", signal_date)];
            if !delayed_sold_symbols.is_empty() {
                notes.push(format!(
@@ -9273,6 +9371,9 @@ impl Strategy for PlatformExprStrategy {
            .filter(|symbol| !delayed_sold_symbols.contains(*symbol))
            .cloned()
            .collect::<BTreeSet<_>>();
+        if self.uses_persistent_model_lifecycle() {
+            slot_working_symbols.extend(self.position_entry_dates.keys().cloned());
+        }
        let daily_top_up_active = self.config.daily_top_up_enabled
            && self.config.rotation_enabled
            && !periodic_rebalance
@@ -9441,7 +9542,9 @@ impl Strategy for PlatformExprStrategy {
            && trading_ratio > 0.0
            && (self.config.target_portfolio_daily_enabled || trading_ratio < 1.0)
            && selection_limit > 0
-            && !ctx.portfolio.positions().is_empty()
+            && (!ctx.portfolio.positions().is_empty()
+                || (self.uses_persistent_model_lifecycle()
+                    && !self.position_entry_dates.is_empty()))
        {
            if aiquant_total_value.is_finite() && aiquant_total_value > 0.0 {
                for position in ctx.portfolio.positions().values() {
@@ -9548,6 +9651,63 @@ impl Strategy for PlatformExprStrategy {
                        }
                    }
                }
+                if self.uses_persistent_model_lifecycle()
+                    && self.config.target_portfolio_daily_enabled
+                {
+                    let model_only_symbols = self
+                        .position_entry_dates
+                        .keys()
+                        .filter(|symbol| {
+                            !ctx.portfolio
+                                .position(symbol)
+                                .is_some_and(|position| position.quantity > 0)
+                        })
+                        .filter(|symbol| !exit_symbols.contains(*symbol))
+                        .cloned()
+                        .collect::<Vec<_>>();
+                    for symbol in model_only_symbols {
+                        let decision_stock = self.stock_state_with_factor_date(
+                            ctx,
+                            decision_date,
+                            selection_factor_date,
+                            &symbol,
+                        )?;
+                        let stock_scale = self.buy_scale(ctx, &day, &decision_stock)?;
+                        let target_value = aiquant_total_value * trading_ratio
+                            / selection_limit as f64
+                            * stock_scale;
+                        if !target_value.is_finite() || target_value <= 0.0 {
+                            continue;
+                        }
+                        let before_qty = projected
+                            .position(&symbol)
+                            .map(|position| position.quantity)
+                            .unwrap_or(0);
+                        self.project_target_value(
+                            ctx,
+                            &mut projected,
+                            projection_date,
+                            &symbol,
+                            target_value,
+                            &mut projected_execution_state,
+                        );
+                        let after_qty = projected
+                            .position(&symbol)
+                            .map(|position| position.quantity)
+                            .unwrap_or(0);
+                        order_intents.push(OrderIntent::TargetValue {
+                            symbol: symbol.clone(),
+                            target_value,
+                            reason: "model_position_target_retry".to_string(),
+                        });
+                        if defer_execution_risk {
+                            deferred_daily_target_values.insert(symbol.clone(), target_value);
+                        }
+                        if after_qty > before_qty {
+                            same_bar_buy_symbols.insert(symbol);
+                        }
+                    }
+                }
                aiquant_available_cash = projected.cash();
            }
        }
@@ -24149,6 +24309,119 @@ mod tests {
        assert_eq!(strategy.max_holding_days_exceeded(symbol), Some(3));
    }

+    #[test]
+    fn platform_signal_price_model_lifecycle_survives_unfilled_buy_and_exits() {
+        let entry_date = d(2024, 1, 18);
+        let signal_date = d(2024, 1, 22);
+        let symbol = "600156.SH";
+        let market = |date, close, prev_close| DailyMarketSnapshot {
+            date,
+            symbol: symbol.to_string(),
+            timestamp: Some(format!("{} 15:00:00", date)),
+            day_open: close,
+            open: close,
+            high: close,
+            low: close,
+            close,
+            last_price: close,
+            bid1: close,
+            ask1: close,
+            prev_close,
+            volume: 1_000_000,
+            minute_volume: 0,
+            bid1_volume: 10_000,
+            ask1_volume: 10_000,
+            trading_phase: Some("close".to_string()),
+            paused: false,
+            upper_limit: close * 1.1,
+            lower_limit: close * 0.9,
+            price_tick: 0.01,
+        };
+        let factor = |date| DailyFactorSnapshot {
+            date,
+            symbol: symbol.to_string(),
+            market_cap_bn: 20.0,
+            free_float_cap_bn: 10.0,
+            pe_ttm: 8.0,
+            turnover_ratio: Some(1.0),
+            effective_turnover_ratio: Some(1.0),
+            extra_factors: BTreeMap::from([("adjustment_factor_backward1".to_string(), 1.0)]),
+        };
+        let data = DataSet::from_components(
+            vec![Instrument {
+                symbol: symbol.to_string(),
+                name: symbol.to_string(),
+                board: "SH".to_string(),
+                round_lot: 100,
+                listed_at: Some(d(2020, 1, 1)),
+                delisted_at: None,
+                status: "active".to_string(),
+            }],
+            vec![
+                market(entry_date, 10.0, 9.8),
+                market(signal_date, 9.1, 10.0),
+            ],
+            vec![factor(entry_date), factor(signal_date)],
+            vec![CandidateEligibility {
+                date: signal_date,
+                symbol: symbol.to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            }],
+            vec![BenchmarkSnapshot {
+                date: signal_date,
+                benchmark: symbol.to_string(),
+                open: 9.1,
+                close: 9.1,
+                prev_close: 10.0,
+                volume: 1_000_000,
+            }],
+        )
+        .expect("dataset");
+        let portfolio = PortfolioState::new(10_000_000.0);
+        let subscriptions = BTreeSet::new();
+        let ctx = StrategyContext {
+            execution_date: signal_date,
+            decision_date: signal_date,
+            decision_index: 2,
+            data: &data,
+            portfolio: &portfolio,
+            futures_account: None,
+            open_orders: &[],
+            dynamic_universe: None,
+            subscriptions: &subscriptions,
+            process_events: &[],
+            active_process_event: None,
+            active_datetime: None,
+            order_events: &[],
+            fills: &[],
+        };
+        let mut cfg = PlatformExprStrategyConfig::microcap_rotation();
+        cfg.rotation_enabled = false;
+        cfg.hold_until_exit_enabled = true;
+        cfg.signal_symbol = symbol.to_string();
+        cfg.benchmark_symbol = symbol.to_string();
+        cfg.stop_loss_expr = "0.08".to_string();
+        cfg.take_profit_expr.clear();
+        cfg.stop_take_reference_price_mode =
+            PlatformStopTakeReferencePriceMode::SignalDayPostAdjustedClose;
+        let mut strategy = PlatformExprStrategy::new(cfg);
+        strategy.remember_position_entry_date(symbol, entry_date);
+
+        let decision = strategy.on_day(&ctx).expect("decision");
+
+        assert!(decision.exit_symbols.contains(symbol), "{decision:?}");
+        assert!(!strategy.position_entry_dates.contains_key(symbol));
+        assert_eq!(strategy.position_holding_days.get(symbol), None);
+    }
+
    #[test]
    fn platform_max_holding_days_exit_preempts_take_profit_exit() {
        let date = d(2025, 2, 26);