zsb/fidc-backtest-engine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
boris
2026-07-17 13:26:57 +08:00
parent 0337cc8a22
commit 5918a03456
2 changed files with 284 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+2
View File
@@ -82,6 +82,8 @@
Source Lake 日线成交量保留原始可用性合同：源 `volume=null` 与真实 `volume=0` 含义不同。依赖成交量的 rolling 窗口只要包含源空值就返回缺失，不得把空值补成 0；停牌日明确提供的 0 成交量仍是合法观测。该合同随 runner 快照版本冻结，旧快照不能跨版本复用。
`holdUntilExit=true` 与 `stopTakeReferencePriceMode=signal_day_post_adjusted_close` 组合表示持久模型组合语义：股票进入模型目标后即记录信号日和后复权参考价，不以买单是否成交为前提。涨停、停牌或其他执行风控导致买单未成交时，模型成员仍占用目标槽位、每天累计模型持有日并继续生成目标仓位；达到止盈、止损或最大模型持有期后才从模型组合移除。实际订单仍由成交日风控独立决定，不得用实际持仓集合覆盖模型目标集合。
## 内置微盘策略
`OmniMicroCapStrategy` 是平台内置的微盘轮动策略，用于 demo、性能验证和策略迁移基线：
crates/fidc-core/src/platform_expr_strategy.rs
+282 -9
View File
@@ -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);