大模型辅助风控运营:建议闭环,不是自动执罚

大模型辅助风控运营:建议闭环,不是自动执罚

Hello,我是小兔大白糖。 读完能把 LLM 放在检索/摘要/建议层,并坚持人工确认与审计,避免模型直接改限额。

大模型辅助风控应停在检索/摘要/建议层,动作必须人工确认与审计,禁止模型直接改限额。

估计阅读时间:42 分钟

LLM 建议与人工确认动作
LLM 建议与人工确认动作 · 点击查看 SVG 原图

一句话结论是什么?

LLM 不是风控的"决策者",而是风控系统的"智能副驾驶":在低延迟决策链路之外的辅助环节(告警分析、规则解释、报告生成、异常摘要)发挥自然语言理解与生成优势,通过 Prompt Engineering(Few-shot / Chain-of-Thought)和结构化输出(JSON Schema)将非结构化风险信息转化为可执行洞察,核心矛盾是**"LLM 推理延迟(>1s)"与"风控实时性(<50ms)"的解耦**——LLM 只参与异步链路,同步拦截仍需规则引擎与模型打分。


1. 这是什么?概念怎么定义

1.1 LLM 在风控中的定位

LLM(Large Language Model)在风控体系中的角色是认知增强层(Cognitive Enhancement Layer),而非决策执行层(Decision Execution Layer)。它解决的是"机器可读但人难读"的风险信息转化问题,以及"人难以穷举但模式可学习"的语义推理问题。

风控体系四层架构中的 LLM 位置:

L1 决策执行层(规则引擎 / ML 模型)  ← LLM 不介入,延迟 < 50ms
L2 特征增强层(图谱 / 时序 / 聚合)   ← LLM 不介入
L3 认知增强层(LLM / NLP)            ← LLM 主战场,异步 < 3s
L4 人工运营层(分析师 / 合规官)       ← LLM 辅助,提升人效

1.2 六大核心应用场景

场景输入输出延迟要求价值
智能告警分析(Alert Triage)原始告警 JSON + 历史处置记录优先级 + 根因分类 + 建议动作< 5s减少 70%+ 无效告警的人工 Review
风险报告生成(Report Generation)时间段内所有决策日志自然语言报告 + 趋势图表描述< 30s合规日报/周报自动生成
规则解释(Rule Explanation)命中规则 ID + 用户交易上下文"人话"解释拦截原因< 2s降低客服工单量,提升用户体验
异常摘要(Anomaly Summarization)聚合后的异常事件序列一段摘要文字,说明"哪里不对劲"< 3s加速分析师定位问题
风险知识问答(Risk KB QA)分析师自然语言提问基于内部文档的精准回答< 5s新人培训,知识沉淀
规则辅助生成(Rule Co-creation)业务描述 + 样例数据规则 DSL 草稿 + 边界 Case 提示< 10s提升规则开发效率

1.3 类比:风控系统像一家医院

  • 规则引擎 = 急诊分诊护士:3 秒钟决定你去哪科(快、准、无情)
  • ML 模型 = CT 扫描仪:看片子的能力比人强,但只输出概率
  • LLM = 主治医师的实习助手:帮医生整理病历、写诊断报告、向病人解释病情——不直接决定治疗方案,但让医生效率翻倍、病人体验更好
  • 同步拦截 = 急诊抢救:必须毫秒级,LLM 不能参与
  • 异步分析 = 术后查房:可以慢慢来,LLM 大展身手

1.4 Prompt Engineering 核心范式

Few-shot Prompting(少样本提示) 类比:像教实习生一样,不给他看教科书,而是给他 3-5 个真实案例,说"照着这个格式做"。

Chain-of-Thought(思维链) 类比:像要求实习生"写出思考过程",而非直接给答案。对风控场景尤其重要——我们需要知道 LLM 为什么判定某笔交易高风险,以便人工复核。

Structured Output(结构化输出) 类比:给实习生一份固定表格,要求他把分析结果填进指定字段,而不是写一段自由发挥的文字。下游系统才能直接消费。


2. 核心原理是什么?

核心原理:模型只产出建议与检索摘要,执罚与改限额必须走人工确认与审计闭环。

2.1 LLM 辅助风控架构全景

llm assist risk ops · 图 2
llm assist risk ops · 图 2 · 点击查看 SVG 原图

关键设计原则:LLM 只出现在异步链路(右侧黄色区域),同步链路(左侧绿色区域)绝不能依赖 LLM 的推理结果做阻断/放行决策。

2.2 交易拦截解释流程(时序图)

llm assist risk ops · 图 3
llm assist risk ops · 图 3 · 点击查看 SVG 原图

2.3 Prompt 工程分层设计

llm assist risk ops · 图 4
llm assist risk ops · 图 4 · 点击查看 SVG 原图

2.4 输出结构化流程

风控场景要求 LLM 输出机器可解析的结构,而非自由文本。标准流程:

  1. Schema 定义:用 JSON Schema 定义输出字段(解释文本、风险等级、建议动作、置信度)
  2. Prompt 注入:在 Prompt 中显式描述 Schema,要求 LLM 严格遵循
  3. 响应解析:用 Jackson 解析 JSON,失败时回退到正则提取
  4. 校验层:校验字段类型、枚举值范围、必填项
  5. 降级策略:解析失败时返回"通用解释模板"

3. 怎么用?关键代码与配置

3.1 LLM Gateway 客户端(WebClient + Resilience4j)

/**
 * LLM Gateway:统一封装对外部大模型服务的调用。
 * 具备:连接池、超时控制、重试、熔断、多 Provider  failover。
 */
@Component
public class LlmGateway {
 
    private static final Logger log = LoggerFactory.getLogger(LlmGateway.class);
 
    private final WebClient webClient;
    private final RetryRegistry retryRegistry;
    private final CircuitBreakerRegistry cbRegistry;
 
    @Value("${llm.openai.api-key}")
    private String apiKey;
 
    @Value("${llm.openai.base-url:https://api.openai.com}")
    private String baseUrl;
 
    @Value("${llm.openai.model:gpt-4o}")
    private String model;
 
    @Value("${llm.timeout-ms:10000}")
    private int timeoutMs;
 
    public LlmGateway(WebClient.Builder builder,
                      RetryRegistry retryRegistry,
                      CircuitBreakerRegistry cbRegistry) {
        this.retryRegistry = retryRegistry;
        this.cbRegistry = cbRegistry;
 
        // 自定义连接池:应对高并发异步调用
        ConnectionProvider provider = ConnectionProvider.builder("llm-pool")
            .maxConnections(100)
            .maxIdleTime(Duration.ofSeconds(30))
            .maxLifeTime(Duration.ofMinutes(5))
            .pendingAcquireTimeout(Duration.ofSeconds(10))
            .evictInBackground(Duration.ofSeconds(30))
            .build();
 
        ReactorClientHttpConnector connector = new ReactorClientHttpConnector(
            HttpClient.create(provider)
                .responseTimeout(Duration.ofMillis(timeoutMs))
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
        );
 
        this.webClient = builder
            .clientConnector(connector)
            .baseUrl(baseUrl)
            .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
            .defaultHeader(HttpHeaders.AUTHORIZATION, "Bearer " + apiKey)
            .build();
    }
 
    /**
     * 同步调用 LLM,带重试与熔断。
     * 适用于:交易解释、告警摘要等异步链路。
     */
    public LlmResponse chatCompletion(List<LlmMessage> messages, LlmRequestConfig config) {
        CircuitBreaker cb = cbRegistry.circuitBreaker("llm-openai");
        Retry retry = retryRegistry.retry("llm-retry");
 
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model(config.getModelOrDefault(model))
            .messages(messages)
            .temperature(config.getTemperatureOrDefault(0.2))
            .maxTokens(config.getMaxTokensOrDefault(2048))
            .responseFormat(ResponseFormat.jsonSchema(config.getJsonSchema()))
            .build();
 
        return Decorators.ofSupplier(() -> doRequest(request))
            .withCircuitBreaker(cb)
            .withRetry(retry)
            .get();
    }
 
    private LlmResponse doRequest(ChatCompletionRequest request) {
        return webClient.post()
            .uri("/v1/chat/completions")
            .bodyValue(request)
            .retrieve()
            .onStatus(HttpStatusCode::is5xxServerError,
                resp -> Mono.error(new LlmServiceException("LLM 服务 5xx")))
            .onStatus(HttpStatusCode::is4xxClientError,
                resp -> resp.bodyToMono(String.class)
                    .flatMap(body -> Mono.error(new LlmClientException("LLM 请求错误: " + body))))
            .bodyToMono(ChatCompletionResponse.class)
            .map(resp -> {
                if (resp.getChoices() == null || resp.getChoices().isEmpty()) {
                    throw new LlmServiceException("LLM 返回空 choices");
                }
                String content = resp.getChoices().get(0).getMessage().getContent();
                return new LlmResponse(content, resp.getUsage().getTotalTokens());
            })
            .block(Duration.ofMillis(timeoutMs));
    }
 
    /**
     * 多 Provider Failover:OpenAI 失败时切本地 LLM(如 vLLM 部署的 Llama3)。
     */
    public LlmResponse chatCompletionWithFailover(List<LlmMessage> messages, LlmRequestConfig config) {
        try {
            return chatCompletion(messages, config);
        } catch (LlmServiceException | CallNotPermittedException e) {
            log.warn("Primary LLM failed, falling back to local LLM", e);
            return localLlmFallback(messages, config);
        }
    }
 
    private LlmResponse localLlmFallback(List<LlmMessage> messages, LlmRequestConfig config) {
        // 调用本地 vLLM / TGI 部署的模型
        // 延迟更低(内网),但能力可能弱于 GPT-4
        // ... 类似 doRequest,只是 baseUrl 不同
        return new LlmResponse("{\"explanation\":\"系统繁忙,请稍后查看详细原因。\"}", 0);
    }
}

3.2 结构化输出定义(JSON Schema + Jackson)

/**
 * 交易拦截解释的结构化输出 Schema。
 * 用作:Prompt 中的格式要求 + 响应反序列化。
 */
public class TransactionExplanationSchema {
 
    /**
     * 生成 OpenAI response_format 所需的 JSON Schema 描述。
     */
    public static String getSchemaDescription() {
        return """
            {
              "type": "object",
              "properties": {
                "explanation": {
                  "type": "string",
                  "description": "面向用户的通俗解释,说明为什么交易被拦截"
                },
                "risk_factors": {
                  "type": "array",
                  "items": {"type": "string"},
                  "description": "触发的风险因子列表"
                },
                "severity": {
                  "type": "string",
                  "enum": ["LOW", "MEDIUM", "HIGH", "CRITICAL"],
                  "description": "风险严重等级"
                },
                "suggested_action": {
                  "type": "string",
                  "enum": ["VERIFY_IDENTITY", "WAIT_24H", "CONTACT_SUPPORT", "NONE"],
                  "description": "建议用户采取的下一步动作"
                },
                "confidence": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 1,
                  "description": "LLM 对解释质量的置信度"
                }
              },
              "required": ["explanation", "risk_factors", "severity", "suggested_action", "confidence"]
            }
            """;
    }
}
 
/**
 * 反序列化后的解释对象。
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TransactionExplanation {
    private String explanation;
    private List<String> riskFactors;
    private Severity severity;
    private SuggestedAction suggestedAction;
    private double confidence;
 
    public enum Severity { LOW, MEDIUM, HIGH, CRITICAL }
    public enum SuggestedAction { VERIFY_IDENTITY, WAIT_24H, CONTACT_SUPPORT, NONE }
}

3.3 Prompt 模板引擎(Few-shot + Chain-of-Thought)

/**
 * 交易解释 Prompt 构建器。
 * 结合 Few-shot 示例与 Chain-of-Thought,引导 LLM 按步骤推理。
 */
@Component
public class ExplanationPromptBuilder {
 
    private static final String SYSTEM_PROMPT = """
        你是一位资深风控分析师,擅长将复杂的风控决策转化为普通用户能理解的语言。
        你的任务是根据风控系统拦截一笔交易的原因,生成一段面向用户的解释。
 
        规则:
        1. 解释必须通俗易懂,避免技术术语(如"IP 画像""设备指纹")
        2. 不得泄露内部风控规则的具体阈值(如"单日限额 5000")
        3. 必须给出用户下一步可以做什么
        4. 输出必须是严格合法的 JSON,符合提供的 Schema
        """;
 
    private static final String FEW_SHOT_EXAMPLES = """
        ## 示例 1(正面示例)
        输入:
        - 用户注册 3 天,首次提现 50000 USDT
        - 命中规则:新用户大额提现
        - 设备:从未使用过的设备
        - IP:与注册地不同国家
 
        思考过程:
        Step 1: 用户注册时间很短,还没有建立信任历史。
        Step 2: 提现金额很大,且使用的是新设备。
        Step 3: IP 地址与注册国家不一致,可能存在账户被盗风险。
        Step 4: 需要引导用户完成身份验证,确认是本人操作。
 
        输出:
        {
          "explanation": "由于您的账户注册时间较短,且本次提现金额较大,同时我们检测到您使用了新的登录设备,为了保护您的资产安全,本次交易需要额外验证。",
          "risk_factors": ["新用户", "大额提现", "新设备"],
          "severity": "MEDIUM",
          "suggested_action": "VERIFY_IDENTITY",
          "confidence": 0.95
        }
 
        ## 示例 2(反面示例——应避免)
        输入:
        - 用户近 1 小时转账 10 笔,每笔 999 USDT(疑似拆分)
 
        错误输出:
        "您的交易因触发规则 R_312(高频拆分转账,阈值 1000 USDT)被拦截。"
        原因:泄露了规则编号和具体阈值,攻击者会针对性绕过。
 
        正确输出:
        {
          "explanation": "我们检测到您的账户在短时间内发生了多笔类似金额的转账,这种交易模式与常见的欺诈行为相似。为了保护所有用户的安全,我们暂时限制了此类交易。",
          "risk_factors": ["高频转账", "金额拆分模式"],
          "severity": "HIGH",
          "suggested_action": "CONTACT_SUPPORT",
          "confidence": 0.92
        }
        """;
 
    private static final String COT_TEMPLATE = """
        现在请分析以下真实案例。
 
        输入:
        {user_context}
 
        请按以下步骤思考:
        Step 1: 识别触发拦截的核心条件(用户历史、交易特征、设备/IP 异常)
        Step 2: 评估这些条件组合在一起的风险含义
        Step 3: 用通俗易懂的语言向用户解释(像客服一样)
        Step 4: 给出用户下一步最合理的动作建议
 
        输出格式(严格 JSON):
        {json_schema}
        """;
 
    public List<LlmMessage> buildPrompt(TransactionContext ctx, UserProfile profile,
                                        List<HitRule> hitRules, DeviceInfo device) {
        String userContext = buildUserContext(ctx, profile, hitRules, device);
        String cotPrompt = COT_TEMPLATE
            .replace("{user_context}", userContext)
            .replace("{json_schema}", TransactionExplanationSchema.getSchemaDescription());
 
        return List.of(
            new LlmMessage("system", SYSTEM_PROMPT),
            new LlmMessage("user", FEW_SHOT_EXAMPLES),
            new LlmMessage("user", cotPrompt)
        );
    }
 
    private String buildUserContext(TransactionContext ctx, UserProfile profile,
                                    List<HitRule> hitRules, DeviceInfo device) {
        StringBuilder sb = new StringBuilder();
        sb.append("- 用户注册天数:").append(profile.getDaysSinceRegistration()).append("\n");
        sb.append("- 历史交易笔数:").append(profile.getTotalTxCount()).append("\n");
        sb.append("- 本次交易类型:").append(ctx.getTxType()).append("\n");
        sb.append("- 本次交易金额:").append(ctx.getAmount()).append(" ").append(ctx.getCurrency()).append("\n");
        sb.append("- 设备信任度:").append(device.getTrustScore()).append("\n");
        sb.append("- 设备是否首次使用:").append(device.isFirstTime()).append("\n");
        sb.append("- IP 国家与注册国家是否一致:").append(ctx.isIpMatchRegistrationCountry()).append("\n");
        sb.append("- 命中规则:").append(hitRules.stream()
            .map(HitRule::getRuleName)
            .collect(Collectors.joining(", "))).append("\n");
        return sb.toString();
    }
}

3.4 交易解释服务(Transaction Explainer Service)

/**
 * 交易拦截解释服务:将风控决策转化为用户可理解的语言。
 * 全异步处理,不阻塞主交易链路。
 */
@Service
@Slf4j
public class TransactionExplainerService {
 
    private final LlmGateway llmGateway;
    private final ExplanationPromptBuilder promptBuilder;
    private final ExplanationRepository explanationRepository;
    private final ObjectMapper objectMapper;
 
    @Value("${llm.explanation.timeout-ms:8000}")
    private int explanationTimeoutMs;
 
    public TransactionExplainerService(LlmGateway llmGateway,
                                       ExplanationPromptBuilder promptBuilder,
                                       ExplanationRepository explanationRepository,
                                       ObjectMapper objectMapper) {
        this.llmGateway = llmGateway;
        this.promptBuilder = promptBuilder;
        this.explanationRepository = explanationRepository;
        this.objectMapper = objectMapper;
    }
 
    /**
     * 异步生成交易解释,结果通过消息队列通知用户端。
     */
    @Async("riskExplanationExecutor")
    public CompletableFuture<ExplanationResult> explainAsync(String eventId,
                                                             TransactionContext ctx,
                                                             UserProfile profile,
                                                             List<HitRule> hitRules,
                                                             DeviceInfo device) {
        long start = System.currentTimeMillis();
        try {
            List<LlmMessage> messages = promptBuilder.buildPrompt(ctx, profile, hitRules, device);
 
            LlmRequestConfig config = LlmRequestConfig.builder()
                .model("gpt-4o-mini")  // 解释任务用轻量模型即可
                .temperature(0.3)      // 低 temperature 降低创意,提高稳定性
                .maxTokens(1024)
                .jsonSchema(TransactionExplanationSchema.getSchemaDescription())
                .build();
 
            LlmResponse response = llmGateway.chatCompletionWithFailover(messages, config);
 
            TransactionExplanation explanation = parseAndValidate(response.getContent());
 
            // 持久化
            ExplanationRecord record = ExplanationRecord.builder()
                .eventId(eventId)
                .userId(ctx.getUserId())
                .explanation(explanation.getExplanation())
                .severity(explanation.getSeverity().name())
                .suggestedAction(explanation.getSuggestedAction().name())
                .confidence(explanation.getConfidence())
                .tokensUsed(response.getTokensUsed())
                .latencyMs(System.currentTimeMillis() - start)
                .createdAt(Instant.now())
                .build();
            explanationRepository.save(record);
 
            log.info("Explanation generated for event={}, latencyMs={}, confidence={}",
                eventId, record.getLatencyMs(), explanation.getConfidence());
 
            return CompletableFuture.completedFuture(
                new ExplanationResult(true, explanation, null));
 
        } catch (Exception e) {
            log.error("Failed to generate explanation for event={}", eventId, e);
            // 降级:返回通用模板
            TransactionExplanation fallback = buildFallbackExplanation(hitRules);
            return CompletableFuture.completedFuture(
                new ExplanationResult(false, fallback, e.getMessage()));
        }
    }
 
    private TransactionExplanation parseAndValidate(String json) {
        try {
            // 清理可能的 markdown 代码块包裹
            String cleaned = json.replaceAll("~~~json\\s*", "")
                                 .replaceAll("~~~\\s*", "").trim();
            TransactionExplanation explanation = objectMapper.readValue(cleaned, TransactionExplanation.class);
 
            // 业务校验
            if (explanation.getConfidence() < 0.5) {
                log.warn("Low confidence explanation: {}", explanation.getConfidence());
            }
            if (explanation.getExplanation() == null || explanation.getExplanation().length() < 10) {
                throw new IllegalArgumentException("Explanation too short or empty");
            }
            return explanation;
        } catch (JsonProcessingException e) {
            throw new LlmParseException("Failed to parse LLM output: " + json, e);
        }
    }
 
    private TransactionExplanation buildFallbackExplanation(List<HitRule> hitRules) {
        String fallbackText = "您的交易触发了安全保护机制,已被暂时拦截。" +
            "如需继续操作,请完成身份验证或联系客服。";
        return TransactionExplanation.builder()
            .explanation(fallbackText)
            .riskFactors(List.of("安全保护拦截"))
            .severity(TransactionExplanation.Severity.MEDIUM)
            .suggestedAction(TransactionExplanation.SuggestedAction.VERIFY_IDENTITY)
            .confidence(0.0)
            .build();
    }
}

3.5 风险告警摘要服务(Alert Summarization)

/**
 * 批量告警智能摘要服务:将一小时内上百条分散的告警聚合成一段可读摘要。
 * 适用于:风控运营团队的每日告警 Review。
 */
@Service
@Slf4j
public class AlertSummarizationService {
 
    private final LlmGateway llmGateway;
 
    @Scheduled(cron = "0 0 * * * ?") // 每小时执行一次
    public void generateHourlySummary() {
        List<Alert> alerts = alertRepository.findByTimeRange(
            Instant.now().minus(1, ChronoUnit.HOURS), Instant.now());
 
        if (alerts.size() < 5) {
            log.info("Too few alerts ({}) to summarize", alerts.size());
            return;
        }
 
        // 先做一次轻量聚合,减少输入 Token
        AlertAggregate aggregate = aggregateAlerts(alerts);
 
        List<LlmMessage> messages = buildSummaryPrompt(aggregate);
        LlmRequestConfig config = LlmRequestConfig.builder()
            .model("gpt-4o")
            .temperature(0.2)
            .maxTokens(2048)
            .build();
 
        try {
            LlmResponse response = llmGateway.chatCompletion(messages, config);
            String summary = response.getContent();
 
            alertSummaryRepository.save(AlertSummary.builder()
                .timeWindowStart(aggregate.getWindowStart())
                .timeWindowEnd(aggregate.getWindowEnd())
                .totalAlerts(alerts.size())
                .summaryText(summary)
                .tokensUsed(response.getTokensUsed())
                .build());
 
            // 推送到 Slack / 飞书
            notificationService.sendAlertSummary(summary, alerts.size());
 
        } catch (Exception e) {
            log.error("Alert summarization failed", e);
        }
    }
 
    private AlertAggregate aggregateAlerts(List<Alert> alerts) {
        Map<String, Long> ruleCounts = alerts.stream()
            .collect(Collectors.groupingBy(Alert::getRuleName, Collectors.counting()));
        Map<String, Long> severityCounts = alerts.stream()
            .collect(Collectors.groupingBy(Alert::getSeverity, Collectors.counting()));
 
        return AlertAggregate.builder()
            .windowStart(alerts.get(0).getCreatedAt())
            .windowEnd(alerts.get(alerts.size() - 1).getCreatedAt())
            .totalCount(alerts.size())
            .ruleDistribution(ruleCounts)
            .severityDistribution(severityCounts)
            .topUsers(alerts.stream()
                .collect(Collectors.groupingBy(Alert::getUserId, Collectors.counting()))
                .entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .limit(5)
                .map(e -> Map.entry(e.getKey(), e.getValue()))
                .collect(Collectors.toList()))
            .build();
    }
 
    private List<LlmMessage> buildSummaryPrompt(AlertAggregate agg) {
        String prompt = String.format("""
            请为风控运营团队生成一段告警摘要报告。
 
            统计信息:
            - 时间窗口:%s 至 %s
            - 告警总数:%d
            - 按规则分布:%s
            - 按严重等级分布:%s
            - 触发告警最多的 5 个用户:%s
 
            要求:
            1. 用中文输出,分为"总体态势""重点关注""建议动作"三部分
            2. 指出是否有集中爆发趋势(某规则或某用户短时间内大量触发)
            3. 给出运营团队的下一步建议(如"需人工复核 TOP1 用户""某规则误杀率可能上升")
            4. 控制在 500 字以内
            """,
            agg.getWindowStart(), agg.getWindowEnd(), agg.getTotalCount(),
            agg.getRuleDistribution(), agg.getSeverityDistribution(),
            agg.getTopUsers()
        );
 
        return List.of(
            new LlmMessage("system", "你是一位资深风控运营分析师,擅长从海量告警中提炼关键信息。"),
            new LlmMessage("user", prompt)
        );
    }
}

3.6 风险报告生成 Pipeline

/**
 * 风险报告生成 Pipeline:将一段时间的风控数据转化为合规报告。
 * 适用于:向监管机构提交的 AML / 反欺诈报告。
 */
@Component
public class RiskReportPipeline {
 
    private final DecisionLogRepository decisionLogRepository;
    private final LlmGateway llmGateway;
 
    /**
     * 生成日报。
     */
    public RiskReport generateDailyReport(LocalDate date) {
        Instant start = date.atStartOfDay(ZoneOffset.UTC).toInstant();
        Instant end = date.plusDays(1).atStartOfDay(ZoneOffset.UTC).toInstant();
 
        // 数据聚合(本地计算,减少 LLM Token)
        ReportData data = decisionLogRepository.aggregateDaily(start, end);
 
        // 第一段:数据概览(结构化数据直接拼接)
        String dataSection = String.format("""
            日期:%s
            总交易请求:%d
            拦截笔数:%d (%.2f%%)
            挑战笔数:%d (%.2f%%)
            放行笔数:%d
            平均决策延迟:%.2f ms
            拦截金额最高币种:%s (%s)
            触发最多的前 3 条规则:%s
            """,
            date, data.getTotalRequests(), data.getBlockedCount(),
            data.getBlockedRate() * 100, data.getChallengedCount(),
            data.getChallengedRate() * 100, data.getAllowedCount(),
            data.getAvgLatencyMs(), data.getTopCurrency(), data.getTopAmount(),
            data.getTopRules()
        );
 
        // 第二段:趋势分析与异常检测(交给 LLM)
        String analysisPrompt = String.format("""
            基于以下风控日报数据,请生成一段分析文字,供合规团队使用。
 
            %s
 
            要求:
            1. 分析拦截率变化趋势(与昨日对比 %+.2f%%)
            2. 指出是否存在异常模式(如某时段集中爆发、某币种异常活跃)
            3. 给出合规角度的建议(如"建议加强对 %s 的监控")
            4. 语气正式、专业,适合直接附在监管报告中
            5. 控制在 800 字以内
            """,
            dataSection,
            data.getBlockedRate() - data.getYesterdayBlockedRate(),
            data.getTopCurrency()
        );
 
        LlmResponse response = llmGateway.chatCompletion(
            List.of(new LlmMessage("user", analysisPrompt)),
            LlmRequestConfig.builder().model("gpt-4o").temperature(0.2).maxTokens(1500).build()
        );
 
        return RiskReport.builder()
            .reportDate(date)
            .dataSection(dataSection)
            .analysisSection(response.getContent())
            .generatedAt(Instant.now())
            .tokensConsumed(response.getTokensUsed())
            .build();
    }
}

3.7 Resilience4j 配置(重试 + 熔断)

@Configuration
public class ResilienceConfig {
 
    @Bean
    public RetryRegistry retryRegistry() {
        RetryConfig config = RetryConfig.custom()
            .maxAttempts(3)
            .waitDuration(Duration.ofMillis(500))
            .retryExceptions(LlmServiceException.class, TimeoutException.class)
            .ignoreExceptions(LlmClientException.class) // 4xx 不重试
            .build();
        return RetryRegistry.of(config);
    }
 
    @Bean
    public CircuitBreakerRegistry circuitBreakerRegistry() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)          // 失败率 > 50% 触发熔断
            .slowCallRateThreshold(80)         // 慢调用 > 80% 触发熔断
            .slowCallDurationThreshold(Duration.ofSeconds(5))
            .waitDurationInOpenState(Duration.ofSeconds(30))
            .permittedNumberOfCallsInHalfOpenState(5)
            .slidingWindowSize(100)
            .build();
        return CircuitBreakerRegistry.of(config);
    }
 
    @Bean("riskExplanationExecutor")
    public Executor riskExplanationExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(8);
        executor.setMaxPoolSize(32);
        executor.setQueueCapacity(500);
        executor.setThreadNamePrefix("risk-llm-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

4. 业界怎么做?

4.1 Shopify:AI 驱动的欺诈订单解释系统

Shopify 的欺诈检测系统 Shopify Protect 每天处理数百万笔电商订单,核心挑战是商家不理解为什么订单被标记为欺诈——导致大量客服工单和误取消。

LLM 应用方案:

  • 场景:当风控模型将订单标记为"高风险"时,自动生成一段向商家解释的文字
  • Prompt 设计:Few-shot + 反例约束(禁止泄露内部信号,如"该用户曾在其他店铺退款")
  • 输出结构化:JSON 格式,包含 explanation(商家可见)、internal_notes(分析师可见)、recommended_action(取消/发货/人工复核)
  • 多语言:利用 LLM 原生多语言能力,直接输出商家店铺设置的本地语言

技术细节:

  • 使用 GPT-4 作为主力模型,GPT-3.5 作为降级
  • 解释延迟要求 < 3s(异步,不阻塞订单处理)
  • 建立了人工反馈闭环:商家对解释的"有帮助/无帮助"点击数据回流,用于微调 Prompt 和筛选 Few-shot 示例

踩过的坑:

  • 幻觉问题:早期版本 LLM 会编造不存在的风险信号(如"该 IP 曾关联诈骗案件")。解决方案:在 Prompt 中强制要求"只基于提供的字段推理,不得引入外部知识",并在后置校验层比对输出与输入字段的一致性。
  • 过度解释:LLM 会写出长篇大论。解决方案:在 Prompt 中明确要求"不超过 3 句话",并在 max_tokens 层面硬限制。

4.2 蚂蚁集团:智能风控运营助手("风语者")

蚂蚁集团的智能风控运营平台内部代号"风语者",核心解决运营分析师每天面对 10 万+ 告警无从看起的问题。

LLM 应用方案:

  • 告警摘要:将 1 小时内的告警按规则类型、用户、金额维度聚合,生成一段摘要。如:"过去 1 小时内,'新用户大额提现'规则触发 312 次,主要集中在 14:00-14:15,TOP3 用户贡献了 40% 的告警量,疑似同一团伙行为,建议启动关联图谱分析。"
  • 自然语言查询:分析师用自然语言提问,"昨天有哪些用户同时命中了规则 A 和规则 B?"LLM 将其转化为内部查询 DSL,执行后返回结果并解释。
  • 规则辅助生成:业务方描述需求"我想拦截注册 7 天内提现超过 1 万的行为",LLM 生成 Drools DSL 草稿 + 边界 Case 提示。

技术细节:

  • 自研大模型(基于通义千问微调),而非直接调用 GPT-4,核心原因是数据安全——交易数据不能出域
  • 采用 RAG(检索增强生成) 架构:将历史告警处置记录、规则文档、案例库向量化存入向量数据库,Prompt 构建时先检索相关文档作为上下文
  • 人工在环(Human-in-the-loop):LLM 生成的规则草稿必须经过资深分析师审核才能上线

关键指标:

  • 告警摘要后,分析师平均 Review 时间从 45 分钟降至 8 分钟
  • 规则开发周期从 3 天缩短到 4 小时(含审核)

4.3 Goldman Sachs:全球市场合规报告生成

高盛的 Marquee 平台需要对全球交易进行实时监控并生成合规报告,满足 MiFID II、Dodd-Frank 等监管要求。

LLM 应用方案:

  • 交易异常摘要:当 CEP 引擎检测到可疑交易模式(如 Spoofing、Layering)时,LLM 生成一段自然语言描述,供合规官快速理解
  • 监管报告起草:基于结构化交易数据,自动生成监管报告草稿,合规官只需审核修改

技术细节:

  • 使用本地部署的开源模型(Llama 2 70B),所有数据留在内网
  • 输出必须通过严格的 Schema 校验,因为报告直接提交给监管机构
  • 建立了双模型校验机制:主模型生成后,用第二个模型检查"是否有遗漏的关键信息",降低幻觉风险

5. 业务场景怎么对照?

5.1 Risk 场景映射(大型加密货币交易所-like 场景)

风控领域具体场景LLM 应用方式不能做什么
Fraud Detection(反欺诈)盗刷检测、账户接管(ATO)生成向用户的拦截解释;汇总异常设备/行为模式摘要不能替代规则引擎做实时阻断决策
AML(反洗钱)大额可疑交易报告(STR)、资金流向分析自动生成 AML 可疑活动 narrative;将复杂资金流向图转化为文字描述不能替代 SAR 判定,最终提交必须人工审核
Transaction Monitoring(交易监控)异常交易模式识别、拆分交易检测解释为什么某笔交易被标记为 structuring;生成监控日报不能在交易执行链路中同步调用
Alert Triage(告警分级)每日数千条风控告警的优先级排序聚合相似告警、生成摘要、推荐处置动作不能无监督自动关闭高严重度告警
Rule Explanation(规则解释)用户询问"为什么我的提现被拒绝了"将命中规则转化为通俗语言,给出解决建议不能泄露规则阈值、规则 ID、内部信号
Anomaly Summarization(异常摘要)团伙攻击、批量注册、羊毛党将分散的异常事件聚合成可读摘要,标注趋势不能直接生成处置指令(封禁/冻结)

5.2 大型加密货币交易所 具体场景示例

场景 1:P2P 交易纠纷解释

  • 背景:用户 A 在 P2P 卖出 USDT 后声称未收到法币,平台冻结资金
  • LLM 应用:根据双方的聊天记录、支付凭证、历史交易记录,生成一份"纠纷摘要"给客服,标注矛盾点和建议问询方向
  • 约束:不得基于单方面的说辞做出判断,必须标注"待核实"

场景 2:新币 Launchpad 反羊毛

  • 背景:某新币申购活动,风控系统检测到 2000 个账户共用相同的资金来源地址
  • LLM 应用:生成活动风控摘要——"本次 Launchpad 共识别 2000 个关联账户,资金来自 3 个母地址,疑似批量操控。建议:取消这些账户的申购资格并加入灰名单观察。"
  • 约束:最终处置仍需人工审批

场景 3:跨链提现风险解释

  • 背景:用户首次向一个新地址提现大额 BTC,触发"新地址+大额"规则
  • LLM 应用:向用户推送——"您正在向一个从未使用过的地址提现大额资产。为保护您的资金安全,请确认该地址属于您本人。如确认无误,请点击验证。"

5.3 常见误区 vs 正确做法

❌ 常见误区✅ 正确做法
在同步拦截链路中调用 LLM 做决策LLM 仅用于异步链路,同步链路保持 < 50ms
让 LLM 直接输出阻断/放行指令LLM 只输出解释/摘要/建议,决策权保留给规则引擎
Prompt 中直接拼接用户输入(Prompt Injection 风险)对用户输入做清洗和转义,使用参数化模板
LLM 输出直接展示给用户,不经校验建立 JSON Schema 校验 + 敏感词过滤 + 幻觉检测
所有场景都用最强模型(GPT-4)简单任务用轻量模型(GPT-4o-mini),复杂分析用强模型,降低成本
忽略 Token 成本,全量日志直接塞给 LLM先做本地聚合/过滤,控制输入 Token 在 4K 以内
单点 LLM 调用,无降级方案多 Provider failover + 本地模型兜底 + 通用模板最终降级

5.4 选型建议

When to use LLM in Risk:

  • 需要将结构化风控数据转化为自然语言(用户解释、监管报告)
  • 需要从大量非结构化文本中提取风险信号(聊天记录、客服工单)
  • 需要辅助分析师做信息汇总和趋势判断
  • 需要多语言风险解释(全球化平台)

When NOT to use LLM in Risk:

  • 同步交易决策(延迟要求 < 100ms)
  • 需要 100% 确定性的规则执行(LLM 有概率输出错误)
  • 涉及严格合规的"是/否"判定(如是否提交 SAR)
  • 输入数据包含高度敏感 PII,且无法脱敏出域

6. 高频问题怎么答?

Q1: LLM 推理延迟通常在 1-5 秒,怎么融入要求 < 50ms 的同步风控链路?

答:不能融入。LLM 在风控体系中的定位是异步认知增强层,绝不参与同步决策链路。

具体解耦方式:

  1. 同步链路:规则引擎 + ML 模型做决策,返回"阻断"时只给出一个错误码(如 RISK_BLOCK_312)
  2. 异步链路:决策事件入 Kafka,由消费服务调用 LLM 生成详细解释,通过 App Push / 邮件 / 站内信异步通知用户
  3. 用户体验:前端先显示"交易被拦截,详细原因正在生成中",5 秒内收到具体解释

类比:医院急诊(同步)和出院小结(异步)——你不能等医生写完出院小结再决定要不要抢救。


Q2: 如何保证 LLM 输出不泄露内部风控规则?

答:三层防护:

第一层——Prompt 层: 在 System Prompt 中明确约束:"禁止输出规则编号、规则阈值、内部评分、设备指纹详情、IP 画像数据。只能使用通俗语言描述风险特征。"

第二层——后置校验层: 用正则或 NLP 检测输出中是否包含敏感模式(如数字 + 货币单位组成的阈值、UUID 格式的规则 ID),命中则替换为通用表述。

第三层——人工审核层: 新上线的解释模板先跑 Shadow Mode,由运营团队抽查 100 条输出,确认无泄露后再全量发布。

反面教材:某平台早期直接让 LLM 解释"因触发规则 R_128(单日提现 > 50000)被拦截",攻击者拿到后针对性拆分为 49999 多笔。


Q3: LLM 的"幻觉"问题在风控场景中怎么解决?

答:风控场景对事实准确性要求极高,幻觉可能导致错误解释引发用户投诉甚至法律风险。

缓解策略:

  1. ** grounding(锚定)**:在 Prompt 中强制要求"所有结论必须基于以下提供的字段,不得引入外部知识",并在后置层校验输出中的事实是否都在输入中有对应
  2. 低 temperature:设置 temperature = 0.1~0.3,降低创造性,提高确定性
  3. JSON Schema 结构化:限制输出为固定字段,减少自由发挥空间
  4. 双模型校验:主模型生成后,用第二个模型做"事实一致性检查"
  5. 人工在环(HITL):高风险场景的解释必须经人工审核后才能发送

兜底策略:所有 LLM 生成的解释都必须标注"本解释由 AI 辅助生成,仅供参考",并保留人工复核入口。


Q4: 风控数据涉及大量用户隐私,如何用 LLM 处理?

答:数据安全是金融风控使用 LLM 的首要障碍,分场景处理:

场景 A:调用外部 LLM API(OpenAI / Claude)

  • 数据脱敏:将 userId 哈希化、金额做区间离散化(如">10000"而非"12345")、IP 只保留国家/城市
  • 签署 BAA(Business Associate Agreement)或 DPA(Data Processing Agreement),确保数据不用于模型训练
  • 优先使用 Azure OpenAI(企业级合规更强)或 Anthropic 的 HIPAA 合规版本

场景 B:本地部署 LLM

  • 使用 vLLM / TGI 在内网部署开源模型(Llama 3、Qwen 2.5、DeepSeek)
  • 数据不出域,满足最严格的合规要求
  • 缺点是模型能力通常弱于 GPT-4,需要更多 Prompt Engineering 补偿

场景 C:Hybrid 模式

  • 敏感数据(PII、交易明细)走本地模型
  • 非敏感聚合数据(报表生成、趋势分析)走外部 API
  • 通过数据分类分级策略自动路由

Q5: Prompt Engineering 和 Fine-tuning 应该如何选择?

答:从风控场景的实践来看,绝大多数情况 Prompt Engineering 足够,Fine-tuning 只在特定场景值得投入。

Prompt Engineering 优先的场景(90%):

  • 交易解释、告警摘要、报告生成
  • 输入格式相对固定,Few-shot 示例能有效引导输出
  • 业务逻辑变化快,Fine-tuning 的模型跟不上节奏

Fine-tuning 值得投入的场景(10%):

  • 需要将 LLM 转化为"风控领域专家",具备大量行业知识(如 AML 法规、各类诈骗模式特征)
  • 输出需要严格遵循内部模板,Prompt 难以稳定约束
  • 日调用量极大(>1000 万次/天),Fine-tuning 后的小模型能显著降低成本

决策公式:

如果(业务变化频率高 || 日调用量 < 100万 || 数据安全要求高)→ Prompt Engineering
如果(领域知识密度高 && 输出格式极严格 && 日调用量 > 1000万)→ Fine-tuning

蚂蚁集团的实践:通用解释用 Prompt Engineering,反洗钱报告生成用基于通义千问的 Fine-tuned 模型。


Q6: 如何评估 LLM 在风控场景中的效果?

答:建立多维评估体系:

效率指标:

  • 告警摘要后分析师 Review 时间缩短比例
  • 客服工单中"询问拦截原因"类工单减少比例
  • 规则开发周期缩短比例

质量指标:

  • 解释准确率:运营团队抽样标注 LLM 输出是否准确反映拦截原因(目标 > 95%)
  • 用户满意度:用户对拦截解释的"有帮助/无帮助"点击率
  • 幻觉率:输出中包含未提供信息的频率(目标 < 1%)

成本指标:

  • 平均每条解释消耗的 Token 数
  • LLM 调用成本占风控运营总成本的比例

安全指标:

  • 规则泄露事件数(必须为 0)
  • LLM 生成内容引发的客诉数

Q7: 如果 LLM 服务完全不可用(如网络中断),风控系统怎么兜底?

答:多层降级策略:

L1:多 Provider Failover

  • OpenAI 失败 → 切 Azure OpenAI → 切 Anthropic Claude

L2:本地模型降级

  • 外部 API 全部失败 → 调用内网 vLLM 部署的轻量模型
  • 轻量模型能力弱,但保证服务不中断

L3:模板降级

  • LLM 完全不可用时,根据命中的规则 ID 匹配预置的通用解释模板
  • 如:规则"新设备大额提现" → 固定返回"您使用了新设备且交易金额较大,请完成身份验证。"
  • 体验下降,但不阻塞业务流程

L4:静默模式

  • 极端情况下不生成解释,只返回错误码
  • 用户看到"交易被拦截,请联系客服了解详情"

关键原则:LLM 的不可用绝不能影响同步交易决策链路,异步解释链路允许降级。


记忆口诀: LLM 是副驾驶,不是主驾驶;异步不同步,解释不决策。 Few-shot 给样例,CoT 写过程,JSON 定格式,校验防幻觉。 脱敏出数据,Schema 保结构,三层做降级,安全大于天。

系列:risk-systems #6