面试系统设计:特征平台

通识对照:风控特征平台:离线生产与在线低延迟服务

面试系统设计:特征平台

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 特征平台全景架构

interview sd feature platform · 图 1
interview sd feature platform · 图 1 · 点击查看 SVG 原图

2.2 特征生命周期状态机

interview sd feature platform · 图 2
interview sd feature platform · 图 2 · 点击查看 SVG 原图

2.3 实时/离线一致性保障流程

interview sd feature platform · 图 3
interview sd feature platform · 图 3 · 点击查看 SVG 原图

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);
        }
    }
}
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外部链上分析 APIRedis规则引擎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: 实时和离线特征不一致,怎么排查?

答: 分层排查:

  1. 数据源不一致:检查 Kafka 和 Hive ODS 的数据量是否一致(可能 Binlog 丢失或 Kafka 重复)
  2. 计算逻辑不一致:对比 Flink SQL 和 Spark SQL 的语义差异(如 COUNT DISTINCT 行为不同)
  3. 时间语义不一致:Flink 用 Event Time + Watermark,Spark 用分区时间,窗口边界可能对不齐
  4. 工具排查:每日抽样 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 只保留索引
  • 热 Key:
    • 本地 Caffeine 缓存做 L1,命中率 80%+,减少 Redis 压力
    • 读写分离,特征更新走主节点,查询走从节点
    • 关键特征做 Key 复制(同一个特征存多份,随机读取)

Q5: 特征查询超时怎么保证风控链路不中断?

答: 三级降级:

  1. L1 降级:单个特征查询超时(如 > 20ms),返回该特征的默认值
  2. L2 降级:过多特征缺失(> 30%)时,触发"保守模式"(如强制人工复核)
  3. L3 降级:Feature Store 整体不可用时,规则引擎仅使用本地缓存特征,模型推理降级为规则兜底

Q6: 特征平台怎么支持模型实验的可复现性?

答: 版本快照机制:

  • 每次模型训练时,记录所用特征的版本号和计算时间戳
  • 特征元数据 immutable,修改即产生新版本
  • 实验复现时,按记录的版本号精确查询历史特征值
  • 数据血缘追踪:从模型 → 特征 → 原始数据表,全链路可追溯

Q7: 如何评估一个特征是否值得加入模型?

答: 特征价值评估四维度:

  1. 预测力:IV(Information Value)、KS 值、单特征 AUC
  2. 稳定性:PSI < 0.1,跨时间/跨客群稳定
  3. 获取成本:计算资源、存储成本、延迟开销
  4. 业务可解释性:风控场景下,黑盒特征可能面临合规挑战

记忆口诀: 特征平台像厨房,注册是菜谱,计算是烹饪,存储是保温,Serving 是出餐。 实时流像快餐,离线批像预制菜,味道必须一致,靠 PSI 来把关。> 下线要小心,血缘先查清,TTL 设好防内存,默认值兜底保平安。