场景	触发条件	说明对象	时效要求
拒贷说明	用户被拒绝信贷申请	用户本人	实时/次日
监管检查	监管机构抽查	监管人员	5-15个工作日
法律诉讼	用户提起申诉/诉讼	法庭/仲裁机构	按司法要求

三、可解释性核心技术：SHAP与LLM结合

3.1 传统SHAP可解释性

SHAP（SHapley Additive exPlanations）是目前金融行业使用最广泛的可解释性方法：

/**
 * SHAP值计算服务
 * 解释每个特征对最终决策的贡献度
 */
@Service
@RequiredArgsConstructor
public class SHAPExplainabilityService {

    private final RiskModel riskModel;
    private final FeatureImportanceRepository featureRepo;

    /**
     * 计算信贷申请的SHAP解释
     * @param application 信贷申请
     * @return 特征贡献度列表，按绝对值排序
     */
    public List<FeatureContribution> explainDecision(LoanApplication application) {
        // 1. 提取特征
        double[] features = featureExtractor.extract(application);
        String[] featureNames = featureExtractor.getFeatureNames();

        // 2. 获取模型预测
        double prediction = riskModel.predict(features);

        // 3. 计算SHAP值（使用TreeExplainer或KernelExplainer）
        double[] shapValues = riskModel.computeShapValues(features);

        // 4. 构建贡献度列表
        List<FeatureContribution> contributions = new ArrayList<>();
        for (int i = 0; i < featureNames.length; i++) {
            contributions.add(FeatureContribution.builder()
                .featureName(featureNames[i])
                .featureValue(features[i])
                .shapValue(shapValues[i])
                .contribution(shapValues[i] > 0 ? "提高通过率" : "降低通过率")
                .importanceRank(0) // 后面排序后赋值
                .build());
        }

        // 5. 按SHAP绝对值排序，取前5个最重要特征
        contributions.sort(Comparator.comparingDouble(
            c -> -Math.abs(c.shapValue())));

        for (int i = 0; i < contributions.size(); i++) {
            contributions.get(i).setImportanceRank(i + 1);
        }

        return contributions.stream().limit(5).collect(toList());
    }

    public record FeatureContribution(
        String featureName,
        double featureValue,
        double shapValue,
        String contribution,
        int importanceRank
    ) {}
}

3.2 用LLM把技术解释转化为用户友好的文字

SHAP值给了技术层面的解释，但用户看到"feature_importance=-0.23"毫无意义。这里用Spring AI把技术数据转成自然语言：

@Service
@RequiredArgsConstructor
public class ExplainabilityReportService {

    private final ChatClient chatClient;
    private final SHAPExplainabilityService shapService;

    /**
     * 生成用户可读的拒贷解释报告
     */
    public RejectionExplanationReport generateUserReport(
            LoanApplication application,
            RiskDecision decision) {

        // 1. 获取SHAP解释
        List<SHAPExplainabilityService.FeatureContribution> contributions =
            shapService.explainDecision(application);

        // 2. 用LLM生成自然语言解释
        String naturalLanguageExplanation = chatClient.prompt()
            .system("""
                你是一个专业的信贷风险专家，需要向申请人解释贷款申请的处理结果。
                要求：
                1. 语言简洁清晰，避免技术术语
                2. 提供建设性的改善建议
                3. 保持专业和尊重的语气
                4. 不得提及具体的算法和模型名称
                5. 严格遵守监管要求，不得歧视性描述
                """)
            .user(u -> u.text("""
                申请人信息摘要：
                - 申请金额：{amount}元
                - 申请期限：{term}个月
                - 审批结果：{result}

                主要影响因素（按重要性排序）：
                {factors}

                请生成一份对申请人友好的解释报告，包括：
                1. 审批结果摘要（1句话）
                2. 主要影响原因（2-3条，用通俗语言）
                3. 改善建议（如果是拒绝，给出1-2条具体建议）
                """)
                .param("amount", application.getAmount())
                .param("term", application.getTerm())
                .param("result", decision.isApproved() ? "通过" : "未通过")
                .param("factors", formatContributions(contributions)))
            .call()
            .content();

        return RejectionExplanationReport.builder()
            .applicationId(application.getId())
            .decisionResult(decision.isApproved() ? "通过" : "未通过")
            .technicalFactors(contributions)
            .userExplanation(naturalLanguageExplanation)
            .reportGeneratedAt(LocalDateTime.now())
            .reportVersion("v1.0")
            .build();
    }

    private String formatContributions(
            List<SHAPExplainabilityService.FeatureContribution> contributions) {
        StringBuilder sb = new StringBuilder();
        for (var c : contributions) {
            sb.append(String.format("- %s：%s（影响强度：%.2f）\n",
                c.featureName(), c.contribution(), Math.abs(c.shapValue())));
        }
        return sb.toString();
    }
}

3.3 监管报告自动生成

/**
 * 监管合规报告生成器
 * 按监管要求格式自动生成合规报告
 */
@Service
@RequiredArgsConstructor
public class RegulatoryReportGenerator {

    private final ChatClient chatClient;
    private final ModelMetricsService metricsService;
    private final FairnessAuditService fairnessService;

    /**
     * 生成季度模型风险报告（满足监管要求）
     */
    public ModelRiskReport generateQuarterlyReport(
            String modelId, YearQuarter quarter) {

        // 收集报告所需数据
        ModelPerformanceData performance = metricsService.getQuarterlyMetrics(
            modelId, quarter);
        FairnessAuditResult fairness = fairnessService.auditModel(modelId, quarter);
        List<ModelIncident> incidents = metricsService.getIncidents(modelId, quarter);

        // 使用LLM生成报告摘要和分析
        String executiveSummary = chatClient.prompt()
            .system("你是一个金融科技合规专家，正在撰写向金融监管机构提交的AI模型风险报告。" +
                   "报告必须专业、准确、符合监管要求，使用规范的金融监管语言。")
            .user(u -> u.text("""
                请根据以下数据，生成一份模型风险季度报告摘要：

                模型ID：{modelId}
                报告期间：{quarter}

                性能指标：
                - KS值：{ks}（基准：>=0.3）
                - AUC：{auc}（基准：>=0.7）
                - 准确率：{accuracy}
                - 不良贷款率：{nplRate}

                公平性检验：
                - 性别群体差异：{genderDisparity}
                - 年龄群体差异：{ageDisparity}
                - 地域群体差异：{regionDisparity}

                本季度事件：{incidentCount}起，其中重大事件{majorIncidentCount}起

                请生成：1）执行摘要（200字内）2）风险评估结论 3）改进建议
                """)
                .param("modelId", modelId)
                .param("quarter", quarter.toString())
                .param("ks", performance.ksValue())
                .param("auc", performance.aucScore())
                .param("accuracy", performance.accuracy())
                .param("nplRate", performance.nplRate())
                .param("genderDisparity", fairness.genderDisparity())
                .param("ageDisparity", fairness.ageDisparity())
                .param("regionDisparity", fairness.regionDisparity())
                .param("incidentCount", incidents.size())
                .param("majorIncidentCount",
                    incidents.stream().filter(ModelIncident::isMajor).count()))
            .call()
            .content();

        return ModelRiskReport.builder()
            .modelId(modelId)
            .quarter(quarter)
            .performance(performance)
            .fairnessAudit(fairness)
            .incidents(incidents)
            .executiveSummary(executiveSummary)
            .reportStatus(ReportStatus.DRAFT)
            .generatedAt(LocalDateTime.now())
            .build();
    }
}

四、数据安全：金融个人信息保护实现

/**
 * 金融数据脱敏服务
 * 确保AI模型只接收合规处理后的数据
 */
@Service
public class FinancialDataMaskingService {

    private static final String PHONE_MASK_PATTERN = "(\\d{3})\\d{4}(\\d{4})";
    private static final String ID_CARD_MASK_PATTERN = "(\\d{6})\\d{8}(\\w{4})";

    /**
     * 对申请数据进行合规脱敏
     * 转换为AI模型可处理的特征格式，同时保护原始数据
     */
    public MaskedLoanFeatures maskForAI(LoanApplication application) {
        return MaskedLoanFeatures.builder()
            // 手机号：只保留前3位和后4位
            .maskedPhone(application.getPhone()
                .replaceAll(PHONE_MASK_PATTERN, "$1****$2"))
            // 身份证：只保留前6位（地区）和最后4位
            .maskedIdCard(application.getIdCard()
                .replaceAll(ID_CARD_MASK_PATTERN, "$1********$2"))
            // 收入：转为区间特征，不保留精确值
            .incomeRange(categorizeIncome(application.getMonthlyIncome()))
            // 年龄：转为年龄段，不保留精确生日
            .ageGroup(categorizeAge(application.getBirthDate()))
            // 地区：只用省级，不用精确地址
            .province(extractProvince(application.getAddress()))
            // 数值特征直接保留（已匿名化）
            .creditScore(application.getCreditScore())
            .existingDebtRatio(application.getDebtRatio())
            .employmentMonths(application.getEmploymentMonths())
            .build();
    }

    private String categorizeIncome(BigDecimal monthlyIncome) {
        if (monthlyIncome.compareTo(new BigDecimal("5000")) < 0) return "LOW";
        if (monthlyIncome.compareTo(new BigDecimal("20000")) < 0) return "MEDIUM";
        if (monthlyIncome.compareTo(new BigDecimal("50000")) < 0) return "HIGH";
        return "VERY_HIGH";
    }

    private String categorizeAge(LocalDate birthDate) {
        int age = Period.between(birthDate, LocalDate.now()).getYears();
        if (age < 30) return "YOUNG";
        if (age < 45) return "MIDDLE";
        if (age < 60) return "SENIOR";
        return "ELDER";
    }

    private String extractProvince(String address) {
        // 提取省级信息
        return address.substring(0, Math.min(3, address.length()));
    }
}

五、模型公平性检验

金融AI不能对特定群体产生系统性歧视，这是监管硬要求。

/**
 * AI模型公平性审计服务
 * 定期检验模型对不同群体的决策是否存在偏见
 */
@Service
@RequiredArgsConstructor
public class FairnessAuditService {

    private final RiskModel riskModel;
    private final LoanRecordRepository loanRepo;

    /**
     * 执行群体公平性检验
     * 计算不同群体的通过率差异，识别潜在歧视
     */
    public FairnessAuditResult auditModel(String modelId, YearQuarter quarter) {
        List<LoanRecord> records = loanRepo.findByQuarter(quarter);

        // 按性别分组统计通过率
        Map<String, Double> approvalRateByGender = records.stream()
            .collect(Collectors.groupingBy(
                LoanRecord::getGender,
                Collectors.averagingDouble(r -> r.isApproved() ? 1.0 : 0.0)
            ));

        // 计算最大差异（Disparate Impact Ratio）
        double maleRate = approvalRateByGender.getOrDefault("MALE", 0.0);
        double femaleRate = approvalRateByGender.getOrDefault("FEMALE", 0.0);
        double genderDIR = Math.min(maleRate, femaleRate) /
                           Math.max(maleRate, femaleRate);

        // 监管标准：DIR < 0.8 被视为存在歧视风险（80%规则）
        FairnessLevel genderFairness = genderDIR >= 0.8
            ? FairnessLevel.PASS
            : FairnessLevel.REVIEW_REQUIRED;

        // 按年龄段分组
        Map<String, Double> approvalRateByAge = records.stream()
            .collect(Collectors.groupingBy(
                LoanRecord::getAgeGroup,
                Collectors.averagingDouble(r -> r.isApproved() ? 1.0 : 0.0)
            ));
        double ageDisparity = calculateMaxDisparity(approvalRateByAge);

        return FairnessAuditResult.builder()
            .modelId(modelId)
            .auditQuarter(quarter)
            .genderDisparityIndex(genderDIR)
            .genderFairnessLevel(genderFairness)
            .ageMaxDisparity(ageDisparity)
            .ageFairnessLevel(ageDisparity <= 0.2 ? FairnessLevel.PASS
                                                   : FairnessLevel.REVIEW_REQUIRED)
            .totalSampleSize(records.size())
            .auditedAt(LocalDateTime.now())
            .build();
    }

    private double calculateMaxDisparity(Map<String, Double> rateMap) {
        if (rateMap.isEmpty()) return 0;
        double max = Collections.max(rateMap.values());
        double min = Collections.min(rateMap.values());
        return max - min;
    }
}

六、总结：金融AI合规的核心原则

做金融AI，合规不是选修课，是必修课。总结为四个原则：

可解释优先：每一个影响用户的AI决策，都必须能说清楚原因。SHAP + LLM的组合，是目前最实用的方案。
数据最小化：AI模型只接触它需要的数据，敏感信息在进入AI之前就脱敏。
公平性定期审计：季度性检查不同群体的通过率差异，发现歧视风险立即处理。
合规基础设施化：可解释性报告、审计日志、监管报告——这些不是一次性任务，是持续运行的系统。

用Spring AI构建这套体系，Java工程师完全可以胜任。监管合规需要的，不是高深的算法，而是扎实的工程能力。