
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
TL;DR
特征平台是风控系统的"数据血液系统",负责将原始交易/行为数据加工为在线推理可用、离线训练一致的特征向量;核心挑战是实时流与离线批的口径统一(Lambda/Kappa 架构选型)、特征生命周期治理(注册/生产/消费/下线的全链路追踪)以及毫秒级在线 Serving 的稳定性保障。
1. 概念定义(是什么)
1.1 特征(Feature)
特征是描述业务实体(用户、设备、交易)在某个时间点的可量化属性,是模型和规则引擎的输入燃料。
风控场景典型特征分类:
| 特征类型 | 计算方式 | 延迟 | 示例 |
|---|---|---|---|
| 实时特征 | Flink 流计算 | 秒级 ~ 分钟级 | 近1小时交易次数、当前会话登录设备数 |
| 近线特征 | Kafka Streams / 内存聚合 | 毫秒级 | 本地缓存的用户风险分、设备指纹相似度 |
| 离线特征 | Spark/Hive 批处理 | T+1 | 近30天交易金额均值、用户生命周期价值 |
| 外部特征 | 第三方 API 查询 | 百毫秒级 | 征信评分、制裁名单匹配结果 |
1.2 特征平台核心能力
┌─────────────────────────────────────────────────────────────┐
│ Feature Platform │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Feature │ │ Feature │ │ Feature │ │ Feature │ │
│ │ Registry │ │ Pipeline │ │ Store │ │ Serving │ │
│ │ (注册中心)│ │ (计算流) │ │ (存储层) │ │ (服务层) │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ ↑ ↑ ↑ ↑ │
│ 元数据管理 实时/离线计算 Redis/StarRocks REST/gRPC │
└─────────────────────────────────────────────────────────────┘
1.3 Lambda vs Kappa 架构
| 维度 | Lambda 架构 | Kappa 架构 |
|---|---|---|
| 核心思想 | 实时流 + 离线批 双路并行 | 只有流计算,离线也走流回放 |
| 一致性 | 难以保证(双路口径易不一致) | 天然一致(同一套流逻辑) |
| 复杂度 | 高(维护两套代码) | 中(需流回放能力) |
| 适用场景 | 已有成熟批处理系统,逐步迁移 | 新建系统,强调口径统一 |
| 业界采用 | 阿里/腾讯/字节(混合) | LinkedIn(主流趋势) |
1.4 类比:特征平台 = 餐厅中央厨房
- Feature Registry = 菜谱管理系统:每道菜(特征)的配方、原料、厨师(负责人)、上下架状态
- Feature Pipeline = 烹饪流水线:实时流水线(快餐窗口,现点现做)+ 离线流水线(预制菜,提前批量加工)
- Feature Store = 保温柜 + 冷库:热菜(Redis)秒取,冷菜(Hive/StarRocks)需解冻
- Feature Serving = 出餐口:服务员(API)按订单(请求)快速组合出餐(特征向量)
- 特征一致性 = 快餐和预制菜味道必须一样:同一个菜谱,不同厨师做出来不能一个咸一个淡
2. 核心原理与图解
2.1 特征平台全景架构
2.2 特征生命周期状态机
2.3 实时/离线一致性保障流程
2.4 核心原理详解
1. Feature Store 分层存储策略
| 存储介质 | 特征类型 | 查询延迟 | 容量 | 适用场景 |
|---|---|---|---|---|
| Caffeine (本地) | 热点特征 | < 1ms | 单机 10万级 | 用户风险分、设备指纹 |
| Redis (分布式缓存) | 实时特征 | 1-5ms | 百万级 | 近线统计(1h/24h窗口) |
| StarRocks (OLAP) | 批量特征 | 10-100ms | 亿级 | 复杂聚合、历史回溯 |
| HBase (宽表) | 高维特征 | 5-20ms | 百亿级 | 用户行为序列、图谱特征 |
2. PSI(Population Stability Index)
PSI 用于衡量两个分布的差异程度:
PSI = Σ (Actual% - Expected%) × ln(Actual% / Expected%)
- PSI < 0.1:分布几乎无变化,一致性好
- 0.1 ≤ PSI < 0.25:轻微漂移,需关注
- PSI ≥ 0.25:显著漂移,必须告警并排查
3. 实时特征的时间窗口一致性
实时 Flink 和离线 Spark 必须保证相同时间窗口的语义:
- 事件时间(Event Time) vs 处理时间(Processing Time):离线用事件时间,实时也必须用事件时间 + Watermark
- 窗口边界:离线按整点切分(00:00-01:00),实时 Flink 窗口必须对齐相同边界
- 延迟数据处理:离线无延迟问题,实时需配置允许延迟(allowedLateness)
3. 语法详解与代码示例(怎么用)
3.1 特征注册中心(Feature Registry)
@Service
public class FeatureRegistryService {
private final JdbcTemplate jdbcTemplate;
private final Cache<String, FeatureDefinition> featureCache;
/**
* 注册新特征(带版本控制和血缘追踪)
*/
@Transactional
public FeatureDefinition registerFeature(FeatureRegistrationRequest request) {
// 1. 校验特征 ID 唯一性
if (featureExists(request.getFeatureId())) {
throw new FeatureAlreadyExistsException(request.getFeatureId());
}
// 2. 生成初始版本
String version = "1.0.0";
// 3. 解析 SQL / UDF 逻辑,提取依赖字段
List<String> dependencies = extractDependencies(request.getComputeLogic());
FeatureDefinition definition = FeatureDefinition.builder()
.featureId(request.getFeatureId())
.featureName(request.getFeatureName())
.owner(request.getOwner())
.category(request.getCategory()) // REALTIME / OFFLINE / EXTERNAL
.valueType(request.getValueType()) // INT / DOUBLE / STRING / VECTOR
.defaultValue(request.getDefaultValue())
.computeLogic(request.getComputeLogic())
.dependencies(dependencies)
.ttlSeconds(request.getTtlSeconds())
.status(FeatureStatus.DRAFT)
.version(version)
.createdAt(Instant.now())
.build();
// 4. 持久化
jdbcTemplate.update(
"""
INSERT INTO feature_registry
(feature_id, feature_name, owner, category, value_type, default_value,
compute_logic, dependencies, ttl_seconds, status, version, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""",
definition.getFeatureId(), definition.getFeatureName(),
definition.getOwner(), definition.getCategory().name(),
definition.getValueType().name(), definition.getDefaultValue(),
definition.getComputeLogic(), String.join(",", dependencies),
definition.getTtlSeconds(), definition.getStatus().name(),
definition.getVersion(), Timestamp.from(definition.getCreatedAt())
);
// 5. 注册血缘关系
for (String dep : dependencies) {
registerLineage(definition.getFeatureId(), dep);
}
featureCache.put(definition.getFeatureId(), definition);
return definition;
}
/**
* 特征变更审批流程
*/
@Transactional
public void approveFeature(String featureId, String approver) {
int updated = jdbcTemplate.update(
"UPDATE feature_registry SET status = 'ACTIVE', approved_by = ?, approved_at = ? " +
"WHERE feature_id = ? AND status = 'REVIEW'",
approver, Timestamp.from(Instant.now()), featureId
);
if (updated == 0) {
throw new IllegalStateException("Feature not in REVIEW status: " + featureId);
}
featureCache.invalidate(featureId);
}
/**
* 获取特征及其所有上游依赖(递归)
*/
public List<FeatureDefinition> getFeatureWithDependencies(String featureId) {
Set<String> visited = new HashSet<>();
List<FeatureDefinition> result = new ArrayList<>();
dfsCollect(featureId, visited, result);
return result;
}
private void dfsCollect(String featureId, Set<String> visited, List<FeatureDefinition> result) {
if (visited.contains(featureId)) return;
visited.add(featureId);
FeatureDefinition feature = getFeature(featureId);
result.add(feature);
for (String dep : feature.getDependencies()) {
dfsCollect(dep, visited, result);
}
}
}3.2 Flink 实时特征计算(SQL + UDF)
public class RealtimeFeatureJob {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
// 1. 注册 Kafka 源表
tableEnv.executeSql("""
CREATE TABLE transaction_events (
transaction_id STRING,
user_id STRING,
amount DECIMAL(18, 8),
currency STRING,
event_time TIMESTAMP(3),
WATERMARK FOR event_time AS event_time - INTERVAL '5' SECOND
) WITH (
'connector' = 'kafka',
'topic' = 'transaction-events',
'properties.bootstrap.servers' = 'kafka:9092',
'format' = 'json',
'scan.startup.mode' = 'latest-offset'
)
""");
// 2. 注册 Redis Sink 表(使用 Flink-Connector-Redis)
tableEnv.executeSql("""
CREATE TABLE redis_feature_sink (
feature_key STRING,
feature_value STRING,
expire_sec INT
) WITH (
'connector' = 'redis',
'host' = 'redis-cluster',
'port' = '6379',
'command' = 'SETEX'
)
""");
// 3. 实时特征计算:用户近 1 小时交易金额总和
Table hourlyAmount = tableEnv.sqlQuery("""
SELECT
CONCAT('feature:user_hourly_amount:', user_id) AS feature_key,
CAST(SUM(amount) AS STRING) AS feature_value,
7200 AS expire_sec -- TTL = 2h
FROM transaction_events
GROUP BY
user_id,
TUMBLE(event_time, INTERVAL '1' HOUR)
""");
// 4. 写入 Redis
hourlyAmount.executeInsert("redis_feature_sink");
env.execute("Realtime Feature Computation");
}
}3.3 特征 Serving API(统一查询 + 本地缓存)
@RestController
@RequestMapping("/api/v1/features")
public class FeatureServingController {
private final FeatureQueryService queryService;
private final FeatureRegistryService registryService;
/**
* 批量特征查询接口(模型/规则引擎调用)
*/
@PostMapping("/batch-query")
public ResponseEntity<BatchFeatureResponse> batchQuery(
@RequestBody @Valid BatchFeatureRequest request) {
long startTime = System.currentTimeMillis();
// 1. 按特征类型分组
Map<FeatureCategory, List<String>> categorized = request.getFeatureIds().stream()
.collect(Collectors.groupingBy(fid ->
registryService.getFeature(fid).getCategory()));
// 2. 并行查询不同类型特征
Map<String, FeatureValue> results = new ConcurrentHashMap<>();
List<CompletableFuture<Void>> futures = new ArrayList<>();
// 实时特征:Redis 查询
if (categorized.containsKey(FeatureCategory.REALTIME)) {
futures.add(CompletableFuture.runAsync(() -> {
List<FeatureValue> values = queryService.queryFromRedis(
request.getEntityId(),
categorized.get(FeatureCategory.REALTIME)
);
values.forEach(v -> results.put(v.getFeatureId(), v));
}));
}
// 离线特征:StarRocks 查询
if (categorized.containsKey(FeatureCategory.OFFLINE)) {
futures.add(CompletableFuture.runAsync(() -> {
List<FeatureValue> values = queryService.queryFromStarRocks(
request.getEntityId(),
categorized.get(FeatureCategory.OFFLINE)
);
values.forEach(v -> results.put(v.getFeatureId(), v));
}));
}
// 外部特征:异步 HTTP 调用
if (categorized.containsKey(FeatureCategory.EXTERNAL)) {
futures.add(CompletableFuture.runAsync(() -> {
List<FeatureValue> values = queryService.queryFromExternal(
request.getEntityId(),
categorized.get(FeatureCategory.EXTERNAL)
);
values.forEach(v -> results.put(v.getFeatureId(), v));
}));
}
// 3. 等待全部完成(带超时)
CompletableFuture<Void> allDone = CompletableFuture.allOf(
futures.toArray(new CompletableFuture[0])
);
try {
allDone.get(50, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
// 超时时使用默认值填充缺失特征
fillDefaults(results, request.getFeatureIds(), registryService);
}
long latency = System.currentTimeMillis() - startTime;
return ResponseEntity.ok(BatchFeatureResponse.builder()
.entityId(request.getEntityId())
.features(results)
.missingFeatures(findMissing(results, request.getFeatureIds()))
.latencyMs(latency)
.timestamp(Instant.now())
.build());
}
private void fillDefaults(Map<String, FeatureValue> results,
List<String> requested,
FeatureRegistryService registry) {
for (String fid : requested) {
if (!results.containsKey(fid)) {
FeatureDefinition def = registry.getFeature(fid);
results.put(fid, FeatureValue.builder()
.featureId(fid)
.value(def.getDefaultValue())
.source("DEFAULT")
.build());
}
}
}
}3.4 PSI 一致性监控服务
@Service
public class PsiMonitorService {
private final JdbcTemplate jdbcTemplate;
private final RedisTemplate<String, String> redisTemplate;
private final AlertManager alertManager;
/**
* 每日定时执行 PSI 监控
*/
@Scheduled(cron = "0 30 2 * * ?") // 每天凌晨 2:30
public void runDailyPsiCheck() {
List<FeatureDefinition> activeFeatures = getActiveFeatures();
for (FeatureDefinition feature : activeFeatures) {
try {
PsiResult psi = calculatePsi(feature);
// 持久化 PSI 历史
jdbcTemplate.update(
"INSERT INTO feature_psi_history (feature_id, psi_value, check_date) VALUES (?, ?, ?)",
feature.getFeatureId(), psi.getPsiValue(), Date.valueOf(LocalDate.now())
);
// 告警判断
if (psi.getPsiValue() > 0.25) {
alertManager.sendAlert("FEATURE_PSI_CRITICAL",
String.format("Feature %s PSI=%.4f, exceeds threshold 0.25",
feature.getFeatureId(), psi.getPsiValue()));
} else if (psi.getPsiValue() > 0.1) {
alertManager.sendAlert("FEATURE_PSI_WARNING",
String.format("Feature %s PSI=%.4f, exceeds threshold 0.1",
feature.getFeatureId(), psi.getPsiValue()));
}
} catch (Exception e) {
log.error("PSI calculation failed for feature: {}", feature.getFeatureId(), e);
}
}
}
/**
* 计算单个特征的 PSI
*/
public PsiResult calculatePsi(FeatureDefinition feature) {
String featureId = feature.getFeatureId();
// 1. 获取离线特征分布(T-1)
List<BinDistribution> offlineDist = queryOfflineDistribution(featureId);
// 2. 获取实时特征分布(抽样)
List<BinDistribution> realtimeDist = queryRealtimeDistribution(featureId);
// 3. 对齐分箱(使用离线分箱边界)
Map<String, BinDistribution> offlineMap = offlineDist.stream()
.collect(Collectors.toMap(BinDistribution::getBinRange, d -> d));
double psi = 0.0;
List<BinPsiDetail> details = new ArrayList<>();
for (BinDistribution realBin : realtimeDist) {
BinDistribution offBin = offlineMap.getOrDefault(realBin.getBinRange(),
BinDistribution.builder().binRange(realBin.getBinRange()).percentage(0.001).build());
double actual = realBin.getPercentage();
double expected = Math.max(offBin.getPercentage(), 0.001); // 避免除零
double binPsi = (actual - expected) * Math.log(actual / expected);
psi += binPsi;
details.add(BinPsiDetail.builder()
.binRange(realBin.getBinRange())
.actualPct(actual)
.expectedPct(expected)
.binPsi(binPsi)
.build());
}
return PsiResult.builder()
.featureId(featureId)
.psiValue(psi)
.checkDate(LocalDate.now())
.binDetails(details)
.build();
}
private List<BinDistribution> queryOfflineDistribution(String featureId) {
// 从 StarRocks/Hive 查询 T-1 的分布
return jdbcTemplate.query(
"""
SELECT bin_range, percentage
FROM feature_offline_stats
WHERE feature_id = ? AND dt = ?
ORDER BY bin_range
""",
(rs, rowNum) -> BinDistribution.builder()
.binRange(rs.getString("bin_range"))
.percentage(rs.getDouble("percentage"))
.build(),
featureId, Date.valueOf(LocalDate.now().minusDays(1))
);
}
private List<BinDistribution> queryRealtimeDistribution(String featureId) {
// 从 Redis 抽样 10000 条实时特征值,内存分箱
Set<String> keys = redisTemplate.keys("feature:" + featureId + ":*");
if (keys == null || keys.isEmpty()) {
return Collections.emptyList();
}
List<Double> samples = new ArrayList<>();
for (String key : keys) {
String val = redisTemplate.opsForValue().get(key);
if (val != null) {
try {
samples.add(Double.parseDouble(val));
} catch (NumberFormatException ignored) {}
}
if (samples.size() >= 10000) break;
}
return computeHistogram(samples, 10); // 10 个分箱
}
}4. 业界案例
4.1 字节跳动:ByteFeature 特征平台
ByteFeature 是字节跳动内部统一的特征平台,支撑抖音、今日头条、广告、风控等多业务线:
架构特点:
- 统一 DSL:自研 SQL-like 特征定义语言,实时和离线共用同一套 DSL,编译为 Flink SQL(实时)和 Spark SQL(离线)
- Feature Store 分层:Redis(热特征 P99 < 5ms)+ ByteGraph(图特征)+ ClickHouse(历史回溯)
- 血缘追踪:自动解析特征 SQL,构建依赖图谱,特征下线时自动通知下游消费方
- AB Test 集成:特征版本与模型实验绑定,新特征先在 5% 流量验证,再全量上线
关键数据:
- 注册特征数:100万+
- 日查询量:1000亿+
- 实时特征延迟:P99 < 2s(从事件发生到 Redis 可查)
- PSI 日监控:自动化巡检,PSI > 0.2 自动告警并冻结特征
4.2 腾讯:金融风控特征中台
腾讯金融云的智能风控平台,特征中台是核心组件:
设计亮点:
- 特征工厂:可视化配置特征计算逻辑,拖拽生成 Flink/Spark 作业,零代码开发特征
- 多级缓存策略:L1 Caffeine(JVM 内)→ L2 Redis Cluster → L3 StarRocks,查询逐级降级
- 一致性保障:
- 实时和离线共用同一套 UDF Jar,确保计算逻辑 100% 一致
- 每日凌晨对账任务比对 Redis 和 Hive 的抽样特征值,差异 > 1% 触发告警
- 生命周期管理:特征注册后 30 天无消费自动标记废弃,90 天无消费自动下线
踩过的坑:
- Redis 大 Key 问题:某用户近 90 天行为序列特征写入单个 Redis String,大小达 2MB,导致查询延迟飙升。解决:拆分为 Hash 分片存储,或转存 HBase。
- Flink 状态过期:TTL 配置错误导致窗口状态无限增长,OOM。解决:严格配置 State TTL + RocksDB 增量 Checkpoint。
4.3 Uber:Michelangelo Palette(开源 Feast 前身)
Uber 的 Michelangelo 平台是业界最早提出 Feature Store 概念的系统之一,其 Palette 组件专门负责特征管理:
- 在线/离线存储分离:在线用 Cassandra(低延迟),离线用 Hive(批量训练)
- 特征回填(Backfill):新特征上线后,自动触发历史数据回填,确保训练集可用
- Serving 优化:特征批量查询(Feature Vector)一次返回模型所需的全部特征,减少 RPC 次数
- 影响分析:特征变更前自动分析影响范围(哪些模型在用),防止误下线关键特征
5. 业务场景对照与注意事项
5.1 风控特征场景映射
| 特征名称 | 类型 | 计算逻辑 | 存储 | 消费方 | TTL |
|---|---|---|---|---|---|
| user_hourly_tx_count | 实时 | Flink 1h 窗口计数 | Redis | 规则引擎 | 2h |
| user_7d_avg_amount | 离线 | Spark 7 天均值 | StarRocks | 模型训练 | T+1 |
| device_fp_similarity | 近线 | 设备指纹服务实时计算 | Caffeine | 规则引擎 | 10min |
| user_graph_degree | 离线 | 关联图谱度数 | HBase | 模型推理 | T+1 |
| address_risk_score | 外部 | 链上分析 API | Redis | 规则引擎 | 24h |
5.2 常见误区 vs 正确做法
| ❌ 常见误区 | ✅ 正确做法 |
|---|---|
| 实时和离线各写一套计算逻辑 | 统一 DSL/UDF,实时 Flink 和离线 Spark 共用同一 Jar |
| 特征无 TTL 永久存储 | 按特征类型设置 TTL,过期自动清理,Redis 内存可控 |
| 特征下线直接删除 | 先标记废弃 → 通知下游 → 观察 30 天 → 确认无消费后下线 |
| 特征查询串行执行 | 按存储类型分组并行查询,CompletableFuture + 超时降级 |
| 忽视特征漂移 | 每日 PSI 监控,漂移超阈值自动告警并暂停模型使用 |
| 所有特征都走实时 | 按延迟需求分层,可容忍 T+1 的走离线批处理,降低成本 |
| 特征无默认值 | 所有特征定义必须设置默认值,缺失时不阻塞主链路 |
5.3 选型建议
When to use 实时特征(Flink):
- 延迟要求 < 1 分钟(如近 1 小时交易频次)
- 事件驱动,需要窗口聚合(tumbling/sliding/session)
- 反欺诈场景的时间敏感特征
When to use 离线特征(Spark/Hive):
- 延迟容忍 T+1(如近 30 天行为均值)
- 需要全量历史数据参与计算
- 模型训练用的 label 特征
When to use 外部特征:
- 数据来自第三方(征信、黑名单、图谱)
- 计算逻辑不可控(如 ML 模型推理结果)
- 注意:必须配置熔断降级,外部服务不可用时不阻塞主链路
6. FAQ 与高频追问
Q1: 实时和离线特征不一致,怎么排查?
答: 分层排查:
- 数据源不一致:检查 Kafka 和 Hive ODS 的数据量是否一致(可能 Binlog 丢失或 Kafka 重复)
- 计算逻辑不一致:对比 Flink SQL 和 Spark SQL 的语义差异(如 COUNT DISTINCT 行为不同)
- 时间语义不一致:Flink 用 Event Time + Watermark,Spark 用分区时间,窗口边界可能对不齐
- 工具排查:每日抽样 1000 条记录,逐条比对实时和离线值,定位差异根因
Q2: 新特征上线后,历史数据怎么补?
答: 特征回填(Backfill)流程:
- 触发时机:特征注册并审批通过后,自动触发回填任务
- 回填方式:Spark 作业回放历史 Kafka 数据(或 Hive 快照),按新特征逻辑计算
- 回填范围:通常回填 30-90 天,满足模型训练需求
- 回填验证:回填完成后抽样比对,确保回填值与实时值一致
- 在线切换:回填完成后,模型训练切换至新特征版本
Q3: 特征平台怎么支持 AB Test?
答: 特征版本与实验绑定:
- 每个特征支持多版本(v1, v2)
- 实验系统分配流量(如 10% 用户走 v2)
- Feature Serving API 根据用户实验组返回对应版本特征值
- 实验结束后, winning version 全量上线,旧版本标记废弃
Q4: Redis 存储特征,怎么解决大 Key 和热 Key 问题?
答: 分层处理:
- 大 Key:
- 列表/序列特征拆分为 Hash 分片(
user:123:seq:0,user:123:seq:1) - 超大特征转存 HBase,Redis 只保留索引
- 列表/序列特征拆分为 Hash 分片(
- 热 Key:
- 本地 Caffeine 缓存做 L1,命中率 80%+,减少 Redis 压力
- 读写分离,特征更新走主节点,查询走从节点
- 关键特征做 Key 复制(同一个特征存多份,随机读取)
Q5: 特征查询超时怎么保证风控链路不中断?
答: 三级降级:
- L1 降级:单个特征查询超时(如 > 20ms),返回该特征的默认值
- L2 降级:过多特征缺失(> 30%)时,触发"保守模式"(如强制人工复核)
- L3 降级:Feature Store 整体不可用时,规则引擎仅使用本地缓存特征,模型推理降级为规则兜底
Q6: 特征平台怎么支持模型实验的可复现性?
答: 版本快照机制:
- 每次模型训练时,记录所用特征的版本号和计算时间戳
- 特征元数据 immutable,修改即产生新版本
- 实验复现时,按记录的版本号精确查询历史特征值
- 数据血缘追踪:从模型 → 特征 → 原始数据表,全链路可追溯
Q7: 如何评估一个特征是否值得加入模型?
答: 特征价值评估四维度:
- 预测力:IV(Information Value)、KS 值、单特征 AUC
- 稳定性:PSI < 0.1,跨时间/跨客群稳定
- 获取成本:计算资源、存储成本、延迟开销
- 业务可解释性:风控场景下,黑盒特征可能面临合规挑战
记忆口诀: 特征平台像厨房,注册是菜谱,计算是烹饪,存储是保温,Serving 是出餐。 实时流像快餐,离线批像预制菜,味道必须一致,靠 PSI 来把关。> 下线要小心,血缘先查清,TTL 设好防内存,默认值兜底保平安。