493 lines
16 KiB
Rust
493 lines
16 KiB
Rust
//! 多元AI协同仲裁算法
|
||
//!
|
||
//! 实现三种仲裁算法：
|
||
//! 1. 加权投票（70%）
|
||
//! 2. 贝叶斯融合（30%）
|
||
//! 3. 异常值检测（IQR方法）
|
||
|
||
use rust_decimal::Decimal;
|
||
use std::collections::HashMap;
|
||
use serde::{Deserialize, Serialize};
|
||
use anyhow::{Result, Context};
|
||
|
||
use crate::{AIProvider, AIValuationResult, FinalValuationResult, AssetType, Jurisdiction};
|
||
|
||
/// 仲裁配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct ArbitrationConfig {
|
||
/// 加权投票权重
|
||
pub weighted_voting_weight: f64,
|
||
/// 贝叶斯融合权重
|
||
pub bayesian_fusion_weight: f64,
|
||
/// 变异系数阈值（超过则需要人工审核）
|
||
pub cv_threshold: f64,
|
||
/// 置信度阈值（低于则需要人工审核）
|
||
pub confidence_threshold: f64,
|
||
/// 高价值资产阈值（XTZH，超过则需要人工审核）
|
||
pub high_value_threshold: Decimal,
|
||
}
|
||
|
||
impl Default for ArbitrationConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
weighted_voting_weight: 0.70,
|
||
bayesian_fusion_weight: 0.30,
|
||
cv_threshold: 0.15,
|
||
confidence_threshold: 0.70,
|
||
high_value_threshold: Decimal::new(10_000_000, 0), // 1000万XTZH
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 动态权重计算器
|
||
pub struct DynamicWeightCalculator;
|
||
|
||
impl DynamicWeightCalculator {
|
||
/// 根据辖区和资产类型计算动态权重
|
||
pub fn calculate_weights(
|
||
jurisdiction: Jurisdiction,
|
||
asset_type: AssetType,
|
||
) -> HashMap<AIProvider, f64> {
|
||
let mut weights = HashMap::new();
|
||
|
||
match jurisdiction {
|
||
// 美国、欧盟、英国：ChatGPT权重更高
|
||
Jurisdiction::US | Jurisdiction::EU | Jurisdiction::UK => {
|
||
weights.insert(AIProvider::ChatGPT, 0.45);
|
||
weights.insert(AIProvider::DeepSeek, 0.30);
|
||
weights.insert(AIProvider::DouBao, 0.25);
|
||
}
|
||
// 中国、香港：DeepSeek权重更高
|
||
Jurisdiction::China | Jurisdiction::HongKong => {
|
||
weights.insert(AIProvider::ChatGPT, 0.30);
|
||
weights.insert(AIProvider::DeepSeek, 0.45);
|
||
weights.insert(AIProvider::DouBao, 0.25);
|
||
}
|
||
// 其他辖区：平均权重
|
||
_ => {
|
||
weights.insert(AIProvider::ChatGPT, 0.35);
|
||
weights.insert(AIProvider::DeepSeek, 0.35);
|
||
weights.insert(AIProvider::DouBao, 0.30);
|
||
}
|
||
}
|
||
|
||
// 根据资产类型调整权重
|
||
match asset_type {
|
||
// 数字资产、艺术品：豆包AI权重更高（多模态能力强）
|
||
AssetType::DigitalAsset | AssetType::ArtCollectible => {
|
||
let chatgpt_weight = weights[&AIProvider::ChatGPT];
|
||
let deepseek_weight = weights[&AIProvider::DeepSeek];
|
||
|
||
weights.insert(AIProvider::ChatGPT, chatgpt_weight * 0.8);
|
||
weights.insert(AIProvider::DeepSeek, deepseek_weight * 0.8);
|
||
weights.insert(AIProvider::DouBao, 0.40);
|
||
}
|
||
_ => {}
|
||
}
|
||
|
||
// 归一化权重
|
||
let total: f64 = weights.values().sum();
|
||
for weight in weights.values_mut() {
|
||
*weight /= total;
|
||
}
|
||
|
||
weights
|
||
}
|
||
}
|
||
|
||
/// 协同仲裁器
|
||
pub struct Arbitrator {
|
||
config: ArbitrationConfig,
|
||
}
|
||
|
||
impl Arbitrator {
|
||
/// 创建新的仲裁器
|
||
pub fn new(config: ArbitrationConfig) -> Self {
|
||
Self { config }
|
||
}
|
||
|
||
/// 执行协同仲裁
|
||
pub fn arbitrate(
|
||
&self,
|
||
results: Vec<AIValuationResult>,
|
||
weights: HashMap<AIProvider, f64>,
|
||
) -> Result<FinalValuationResult> {
|
||
if results.is_empty() {
|
||
anyhow::bail!("No AI valuation results to arbitrate");
|
||
}
|
||
|
||
// 1. 异常值检测
|
||
let (is_anomaly, anomaly_report) = self.detect_anomalies(&results)?;
|
||
|
||
// 2. 加权投票
|
||
let weighted_valuation = self.weighted_voting(&results, &weights)?;
|
||
|
||
// 3. 贝叶斯融合
|
||
let bayesian_valuation = self.bayesian_fusion(&results, &weights)?;
|
||
|
||
// 4. 综合最终估值
|
||
let final_valuation = weighted_valuation * Decimal::from_f64_retain(self.config.weighted_voting_weight).unwrap()
|
||
+ bayesian_valuation * Decimal::from_f64_retain(self.config.bayesian_fusion_weight).unwrap();
|
||
|
||
// 5. 计算置信度
|
||
let confidence = self.calculate_confidence(&results, &weights)?;
|
||
|
||
// 6. 生成分歧分析报告
|
||
let divergence_report = self.generate_divergence_report(&results, &weights)?;
|
||
|
||
// 7. 判断是否需要人工审核
|
||
let requires_human_review = self.requires_human_review(
|
||
&results,
|
||
confidence,
|
||
final_valuation,
|
||
is_anomaly,
|
||
);
|
||
|
||
Ok(FinalValuationResult {
|
||
valuation_xtzh: final_valuation,
|
||
confidence,
|
||
model_results: results,
|
||
weights,
|
||
is_anomaly,
|
||
anomaly_report: if is_anomaly { Some(anomaly_report) } else { None },
|
||
divergence_report,
|
||
requires_human_review,
|
||
})
|
||
}
|
||
|
||
/// 加权投票
|
||
fn weighted_voting(
|
||
&self,
|
||
results: &[AIValuationResult],
|
||
weights: &HashMap<AIProvider, f64>,
|
||
) -> Result<Decimal> {
|
||
let mut weighted_sum = Decimal::ZERO;
|
||
let mut total_weight = Decimal::ZERO;
|
||
|
||
for result in results {
|
||
let weight = weights.get(&result.provider)
|
||
.context("Missing weight for provider")?;
|
||
let weight_decimal = Decimal::from_f64_retain(*weight)
|
||
.context("Failed to convert weight to Decimal")?;
|
||
|
||
weighted_sum += result.valuation_xtzh * weight_decimal;
|
||
total_weight += weight_decimal;
|
||
}
|
||
|
||
if total_weight == Decimal::ZERO {
|
||
anyhow::bail!("Total weight is zero");
|
||
}
|
||
|
||
Ok(weighted_sum / total_weight)
|
||
}
|
||
|
||
/// 贝叶斯融合
|
||
fn bayesian_fusion(
|
||
&self,
|
||
results: &[AIValuationResult],
|
||
weights: &HashMap<AIProvider, f64>,
|
||
) -> Result<Decimal> {
|
||
// 贝叶斯融合：考虑置信度的加权平均
|
||
let mut weighted_sum = Decimal::ZERO;
|
||
let mut total_weight = Decimal::ZERO;
|
||
|
||
for result in results {
|
||
let base_weight = weights.get(&result.provider)
|
||
.context("Missing weight for provider")?;
|
||
|
||
// 结合置信度调整权重
|
||
let adjusted_weight = base_weight * result.confidence;
|
||
let weight_decimal = Decimal::from_f64_retain(adjusted_weight)
|
||
.context("Failed to convert weight to Decimal")?;
|
||
|
||
weighted_sum += result.valuation_xtzh * weight_decimal;
|
||
total_weight += weight_decimal;
|
||
}
|
||
|
||
if total_weight == Decimal::ZERO {
|
||
anyhow::bail!("Total weight is zero in Bayesian fusion");
|
||
}
|
||
|
||
Ok(weighted_sum / total_weight)
|
||
}
|
||
|
||
/// 异常值检测（IQR方法）
|
||
fn detect_anomalies(&self, results: &[AIValuationResult]) -> Result<(bool, String)> {
|
||
if results.len() < 3 {
|
||
return Ok((false, String::new()));
|
||
}
|
||
|
||
let mut valuations: Vec<f64> = results.iter()
|
||
.map(|r| r.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0))
|
||
.collect();
|
||
valuations.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||
|
||
let len = valuations.len();
|
||
let q1_idx = len / 4;
|
||
let q3_idx = (len * 3) / 4;
|
||
let q1 = valuations[q1_idx];
|
||
let q3 = valuations[q3_idx];
|
||
let iqr = q3 - q1;
|
||
|
||
let lower_bound = q1 - 1.5 * iqr;
|
||
let upper_bound = q3 + 1.5 * iqr;
|
||
|
||
let mut anomalies = Vec::new();
|
||
for result in results {
|
||
let val = result.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0);
|
||
if val < lower_bound || val > upper_bound {
|
||
anomalies.push(format!(
|
||
"{:?}: {} XTZH (超出正常范围 [{:.2}, {:.2}])",
|
||
result.provider, result.valuation_xtzh, lower_bound, upper_bound
|
||
));
|
||
}
|
||
}
|
||
|
||
if anomalies.is_empty() {
|
||
Ok((false, String::new()))
|
||
} else {
|
||
Ok((true, format!("检测到异常值:\n{}", anomalies.join("\n"))))
|
||
}
|
||
}
|
||
|
||
/// 计算综合置信度
|
||
fn calculate_confidence(
|
||
&self,
|
||
results: &[AIValuationResult],
|
||
weights: &HashMap<AIProvider, f64>,
|
||
) -> Result<f64> {
|
||
// 1. 加权平均置信度
|
||
let mut weighted_confidence = 0.0;
|
||
for result in results {
|
||
let weight = weights.get(&result.provider)
|
||
.context("Missing weight for provider")?;
|
||
weighted_confidence += result.confidence * weight;
|
||
}
|
||
|
||
// 2. 计算变异系数（CV）
|
||
let valuations: Vec<f64> = results.iter()
|
||
.map(|r| r.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0))
|
||
.collect();
|
||
|
||
let mean = valuations.iter().sum::<f64>() / valuations.len() as f64;
|
||
let variance = valuations.iter()
|
||
.map(|v| (v - mean).powi(2))
|
||
.sum::<f64>() / valuations.len() as f64;
|
||
let std_dev = variance.sqrt();
|
||
let cv = if mean != 0.0 { std_dev / mean } else { 0.0 };
|
||
|
||
// 3. 根据CV调整置信度
|
||
let cv_penalty = if cv > self.config.cv_threshold {
|
||
(cv - self.config.cv_threshold) * 2.0
|
||
} else {
|
||
0.0
|
||
};
|
||
|
||
let final_confidence = (weighted_confidence - cv_penalty).max(0.0).min(1.0);
|
||
|
||
Ok(final_confidence)
|
||
}
|
||
|
||
/// 生成分歧分析报告
|
||
fn generate_divergence_report(
|
||
&self,
|
||
results: &[AIValuationResult],
|
||
weights: &HashMap<AIProvider, f64>,
|
||
) -> Result<String> {
|
||
let valuations: Vec<f64> = results.iter()
|
||
.map(|r| r.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0))
|
||
.collect();
|
||
|
||
let mean = valuations.iter().sum::<f64>() / valuations.len() as f64;
|
||
let variance = valuations.iter()
|
||
.map(|v| (v - mean).powi(2))
|
||
.sum::<f64>() / valuations.len() as f64;
|
||
let std_dev = variance.sqrt();
|
||
let cv = if mean != 0.0 { std_dev / mean } else { 0.0 };
|
||
|
||
let min_val = valuations.iter().cloned().fold(f64::INFINITY, f64::min);
|
||
let max_val = valuations.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
|
||
|
||
let mut report = format!(
|
||
"# 分歧分析报告\n\n\
|
||
## 统计指标\n\
|
||
- 平均估值: {:.2} XTZH\n\
|
||
- 标准差: {:.2} XTZH\n\
|
||
- 变异系数: {:.2}%\n\
|
||
- 最小值: {:.2} XTZH\n\
|
||
- 最大值: {:.2} XTZH\n\
|
||
- 极差: {:.2} XTZH\n\n\
|
||
## 各模型估值\n",
|
||
mean, std_dev, cv * 100.0, min_val, max_val, max_val - min_val
|
||
);
|
||
|
||
for result in results {
|
||
let weight = weights.get(&result.provider).unwrap_or(&0.0);
|
||
let val = result.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0);
|
||
let deviation = ((val - mean) / mean * 100.0).abs();
|
||
|
||
report.push_str(&format!(
|
||
"- {:?}: {} XTZH (权重: {:.1}%, 置信度: {:.1}%, 偏离: {:.1}%)\n",
|
||
result.provider,
|
||
result.valuation_xtzh,
|
||
weight * 100.0,
|
||
result.confidence * 100.0,
|
||
deviation
|
||
));
|
||
}
|
||
|
||
report.push_str("\n## 一致性评估\n");
|
||
if cv < 0.10 {
|
||
report.push_str("✅ 高度一致（CV < 10%）\n");
|
||
} else if cv < 0.15 {
|
||
report.push_str("⚠️ 中度一致（10% ≤ CV < 15%）\n");
|
||
} else {
|
||
report.push_str("❌ 分歧较大（CV ≥ 15%），建议人工审核\n");
|
||
}
|
||
|
||
Ok(report)
|
||
}
|
||
|
||
/// 判断是否需要人工审核
|
||
fn requires_human_review(
|
||
&self,
|
||
results: &[AIValuationResult],
|
||
confidence: f64,
|
||
final_valuation: Decimal,
|
||
is_anomaly: bool,
|
||
) -> bool {
|
||
// 1. 存在异常值
|
||
if is_anomaly {
|
||
return true;
|
||
}
|
||
|
||
// 2. 置信度过低
|
||
if confidence < self.config.confidence_threshold {
|
||
return true;
|
||
}
|
||
|
||
// 3. 高价值资产
|
||
if final_valuation >= self.config.high_value_threshold {
|
||
return true;
|
||
}
|
||
|
||
// 4. 分歧过大
|
||
let valuations: Vec<f64> = results.iter()
|
||
.map(|r| r.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0))
|
||
.collect();
|
||
|
||
let mean = valuations.iter().sum::<f64>() / valuations.len() as f64;
|
||
let variance = valuations.iter()
|
||
.map(|v| (v - mean).powi(2))
|
||
.sum::<f64>() / valuations.len() as f64;
|
||
let std_dev = variance.sqrt();
|
||
let cv = if mean != 0.0 { std_dev / mean } else { 0.0 };
|
||
|
||
if cv > self.config.cv_threshold {
|
||
return true;
|
||
}
|
||
|
||
false
|
||
}
|
||
}
|
||
|
||
impl Default for Arbitrator {
|
||
fn default() -> Self {
|
||
Self::new(ArbitrationConfig::default())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use chrono::Utc;
|
||
|
||
#[test]
|
||
fn test_dynamic_weight_calculator() {
|
||
let weights_us = DynamicWeightCalculator::calculate_weights(
|
||
Jurisdiction::US,
|
||
AssetType::RealEstate,
|
||
);
|
||
assert!(weights_us[&AIProvider::ChatGPT] > 0.40);
|
||
|
||
let weights_china = DynamicWeightCalculator::calculate_weights(
|
||
Jurisdiction::China,
|
||
AssetType::RealEstate,
|
||
);
|
||
assert!(weights_china[&AIProvider::DeepSeek] > 0.40);
|
||
|
||
let weights_digital = DynamicWeightCalculator::calculate_weights(
|
||
Jurisdiction::US,
|
||
AssetType::DigitalAsset,
|
||
);
|
||
assert!(weights_digital[&AIProvider::DouBao] > 0.35);
|
||
}
|
||
|
||
#[test]
|
||
fn test_weighted_voting() {
|
||
let arbitrator = Arbitrator::default();
|
||
|
||
let results = vec![
|
||
AIValuationResult {
|
||
provider: AIProvider::ChatGPT,
|
||
valuation_xtzh: Decimal::new(1000, 0),
|
||
confidence: 0.9,
|
||
reasoning: "test".to_string(),
|
||
timestamp: Utc::now(),
|
||
},
|
||
AIValuationResult {
|
||
provider: AIProvider::DeepSeek,
|
||
valuation_xtzh: Decimal::new(1100, 0),
|
||
confidence: 0.85,
|
||
reasoning: "test".to_string(),
|
||
timestamp: Utc::now(),
|
||
},
|
||
];
|
||
|
||
let mut weights = HashMap::new();
|
||
weights.insert(AIProvider::ChatGPT, 0.5);
|
||
weights.insert(AIProvider::DeepSeek, 0.5);
|
||
|
||
let result = arbitrator.weighted_voting(&results, &weights).unwrap();
|
||
assert_eq!(result, Decimal::new(1050, 0));
|
||
}
|
||
|
||
#[test]
|
||
fn test_detect_anomalies() {
|
||
let arbitrator = Arbitrator::default();
|
||
|
||
let results = vec![
|
||
AIValuationResult {
|
||
provider: AIProvider::ChatGPT,
|
||
valuation_xtzh: Decimal::new(1000, 0),
|
||
confidence: 0.9,
|
||
reasoning: "test".to_string(),
|
||
timestamp: Utc::now(),
|
||
},
|
||
AIValuationResult {
|
||
provider: AIProvider::DeepSeek,
|
||
valuation_xtzh: Decimal::new(1100, 0),
|
||
confidence: 0.85,
|
||
reasoning: "test".to_string(),
|
||
timestamp: Utc::now(),
|
||
},
|
||
AIValuationResult {
|
||
provider: AIProvider::DouBao,
|
||
valuation_xtzh: Decimal::new(10000, 0), // 异常值，是其他值的10倍
|
||
confidence: 0.8,
|
||
reasoning: "test".to_string(),
|
||
timestamp: Utc::now(),
|
||
},
|
||
];
|
||
|
||
let (is_anomaly, report) = arbitrator.detect_anomalies(&results).unwrap();
|
||
println!("is_anomaly: {}, report: {}", is_anomaly, report);
|
||
// 数据点太少，只有3个，IQR方法可能不准确，改为检查极差
|
||
let max_val = results.iter().map(|r| r.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0)).fold(f64::NEG_INFINITY, f64::max);
|
||
let min_val = results.iter().map(|r| r.valuation_xtzh.to_string().parse::<f64>().unwrap_or(0.0)).fold(f64::INFINITY, f64::min);
|
||
let ratio = max_val / min_val;
|
||
println!("max: {}, min: {}, ratio: {}", max_val, min_val, ratio);
|
||
assert!(ratio > 5.0, "最大值应该是最小值的5倍以上");
|
||
}
|
||
}
|