# 建模目标定义
modeling_objective = {
    "problem_type": "诊断问题",
    "target": "根据软件测试结果和运行日志，诊断潜在缺陷类型",
    "inputs": [
        "测试用例执行结果",
        "代码覆盖率",
        "运行时异常日志",
        "性能指标"
    ],
    "outputs": [
        "缺陷类型（逻辑错误/内存泄漏/并发问题等）",
        "缺陷位置（模块/类/函数）",
        "严重程度评估"
    ],
    "constraints": [
        "实时性要求：< 5秒",
        "准确率要求：> 85%",
        "可解释性要求：输出诊断依据"
    ]
}

from enum import Enum

class VariableType(Enum):
    """变量类型枚举"""
    ROOT_CAUSE = "root_cause"           # 根原因（无父节点）
    INTERMEDIATE = "intermediate"       # 中间节点
    OBSERVABLE = "observable"           # 可观测节点
    TARGET = "target"                   # 目标节点（诊断目标）

class VariableState(Enum):
    """变量状态枚举"""
    BINARY = "binary"                   # 二值（是/否）
    DISCRETE = "discrete"               # 离散（多个状态）
    CONTINUOUS = "continuous"           # 连续值

class DUCGVariable:
    """DUCG变量定义"""
    def __init__(self, name, var_type, state_type, states=None):
        self.name = name
        self.var_type = var_type
        self.state_type = state_type
        
        # 定义状态空间
        if state_type == VariableState.BINARY:
            self.states = ['False', 'True']
        elif state_type == VariableState.DISCRETE:
            self.states = states if states else []
        else:  # CONTINUOUS
            self.states = None  # 连续变量需要离散化
        
        self.parents = []      # 父节点
        self.children = []     # 子节点
        self.probability = {}  # 条件概率表
        self.strength = {}     # 因果强度
    
    def add_parent(self, parent_var):
        """添加父节点"""
        if parent_var not in self.parents:
            self.parents.append(parent_var)
            parent_var.children.append(self)
    
    def set_causal_strength(self, parent_var, strength):
        """设置因果强度"""
        self.strength[parent_var.name] = strength
    
    def __repr__(self):
        return f"DUCGVariable(name={self.name}, type={self.var_type.value})"

# 定义软件缺陷诊断问题的变量

# 1. 根原因变量（潜在缺陷类型）
defect_logic_error = DUCGVariable(
    name="逻辑错误",
    var_type=VariableType.ROOT_CAUSE,
    state_type=VariableState.BINARY
)

defect_memory_leak = DUCGVariable(
    name="内存泄漏",
    var_type=VariableType.ROOT_CAUSE,
    state_type=VariableState.BINARY
)

defect_concurrency = DUCGVariable(
    name="并发问题",
    var_type=VariableType.ROOT_CAUSE,
    state_type=VariableState.BINARY
)

# 2. 中间变量（症状/表现）
symptom_crash = DUCGVariable(
    name="程序崩溃",
    var_type=VariableType.INTERMEDIATE,
    state_type=VariableState.BINARY
)

symptom_slow_performance = DUCGVariable(
    name="性能下降",
    var_type=VariableType.INTERMEDIATE,
    state_type=VariableState.DISCRETE,
    states=["正常", "轻微", "严重"]
)

symptom_memory_usage = DUCGVariable(
    name="内存占用异常",
    var_type=VariableType.INTERMEDIATE,
    state_type=VariableState.BINARY
)

# 3. 可观测变量（测试结果）
obs_test_failure = DUCGVariable(
    name="测试失败率",
    var_type=VariableType.OBSERVABLE,
    state_type=VariableState.DISCRETE,
    states=["低", "中", "高"]
)

obs_code_coverage = DUCGVariable(
    name="代码覆盖率",
    var_type=VariableType.OBSERVABLE,
    state_type=VariableState.DISCRETE,
    states=["低", "中", "高"]
)

obs_exception_count = DUCGVariable(
    name="异常数量",
    var_type=VariableType.OBSERVABLE,
    state_type=VariableState.DISCRETE,
    states=["少", "中", "多"]
)

# 4. 目标变量（综合诊断结果）
target_defect_severity = DUCGVariable(
    name="缺陷严重程度",
    var_type=VariableType.TARGET,
    state_type=VariableState.DISCRETE,
    states=["低", "中", "高", "严重"]
)

def determine_variable_granularity(system_complexity, available_data, time_constraint):
    """自动确定变量粒度"""
    if system_complexity == "low" and time_constraint == "strict":
        return "coarse"
    elif system_complexity == "high" and available_data == "abundant":
        return "fine"
    else:
        return "multi_level"

# 示例
granularity = determine_variable_granularity(
    system_complexity="medium",
    available_data="moderate",
    time_constraint="moderate"
)
print(f"推荐变量粒度: {granularity}")

class CausalRelationshipBuilder:
    def __init__(self):
        self.relationships = []
    
    def add_expert_knowledge(self, cause, effect, strength, confidence):
        """添加专家给出的因果关系"""
        self.relationships.append({
            'cause': cause,
            'effect': effect,
            'strength': strength,       # 因果强度 [0, 1]
            'confidence': confidence,   # 置信度 [0, 1]
            'source': 'expert'
        })
    
    def add_data_driven(self, cause, effect, strength, p_value):
        """添加数据驱动发现的因果关系"""
        self.relationships.append({
            'cause': cause,
            'effect': effect,
            'strength': strength,
            'p_value': p_value,
            'source': 'data'
        })
    
    def merge_relationships(self):
        """融合专家知识与数据发现"""
        merged = {}
        
        for rel in self.relationships:
            key = (rel['cause'], rel['effect'])
            
            if key not in merged:
                merged[key] = rel
            else:
                # 融合策略：加权平均
                existing = merged[key]
                if existing['source'] == 'expert' and rel['source'] == 'data':
                    # 专家知识权重0.6，数据权重0.4
                    merged[key]['strength'] = (
                        0.6 * existing['strength'] + 
                        0.4 * rel['strength']
                    )
                    merged[key]['source'] = 'hybrid'
        
        return list(merged.values())

# 使用示例
builder = CausalRelationshipBuilder()

# 专家知识
builder.add_expert_knowledge(
    cause=defect_memory_leak,
    effect=symptom_memory_usage,
    strength=0.8,
    confidence=0.9
)

# 数据驱动
builder.add_data_driven(
    cause=defect_logic_error,
    effect=symptom_crash,
    strength=0.75,
    p_value=0.001
)

# 融合
final_relationships = builder.merge_relationships()

from causallearn.search.ConstraintBased.PC import pc
import numpy as np

def discover_causal_structure(data, alpha=0.05):
    """使用PC算法发现因果结构"""
    # 运行PC算法
    cg = pc(
        data.values,
        alpha=alpha,
        indep_test='fisherz',  # 独立性检验方法
        stable=True,
        uc_rule=0,
        uc_priority=2
    )
    
    # 提取因果图
    causal_graph = cg.G.graph
    
    # 可视化
    import networkx as nx
    G = nx.DiGraph()
    
    for i in range(len(data.columns)):
        for j in range(len(data.columns)):
            if causal_graph[i, j] == 1:  # 有向边
                G.add_edge(data.columns[i], data.columns[j])
    
    return G

# 使用示例
import pandas as pd
data = pd.read_csv('software_metrics.csv')
causal_graph = discover_causal_structure(data)

# 可视化
import matplotlib.pyplot as plt
pos = nx.spring_layout(causal_graph)
nx.draw(causal_graph, pos, with_labels=True, 
        node_color='lightblue', 
        node_size=2000,
        font_size=10,
        arrows=True)
plt.title('发现的因果结构')
plt.show()

from pgmpy.estimators import HillClimbSearch, BicScore
from pgmpy.models import BayesianNetwork

def learn_causal_structure_greedy(data):
    """使用爬山搜索学习因果结构"""
    # 定义评分函数（BIC分数）
    scoring_method = BicScore(data)
    
    # 爬山搜索
    hc = HillClimbSearch(data)
    best_model = hc.estimate(
        scoring_method=scoring_method,
        max_indegree=4,        # 最大入度限制
        max_iter=100,
        show_progress=True
    )
    
    return best_model

# 使用示例
learned_structure = learn_causal_structure_greedy(data)
print("学习到的边:")
print(learned_structure.edges())

import dowhy
from dowhy import CausalModel

def discover_causal_effects(data, treatment, outcome, confounders):
    """使用DoWhy进行因果效应估计"""
    # 定义因果图
    causal_graph = f"""
    digraph {{
        {' -> '.join([f'"{c}" -> "{outcome}"' for c in confounders])}
        "{treatment}" -> "{outcome}";
        {' -> '.join([f'"{c}" -> "{treatment}"' for c in confounders])}
    }}
    """
    
    # 创建因果模型
    model = CausalModel(
        data=data,
        treatment=treatment,
        outcome=outcome,
        graph=causal_graph
    )
    
    # 识别因果效应
    identified_estimand = model.identify_effect(proceed_when_unidentifiable=True)
    
    # 估计因果效应
    causal_estimate = model.estimate_effect(
        identified_estimand,
        method_name="backdoor.propensity_score_matching"
    )
    
    # 反驳分析（敏感性测试）
    refutation = model.refute_estimate(
        identified_estimand,
        causal_estimate,
        method_name="random_common_cause"
    )
    
    return causal_estimate, refutation

# 使用示例
treatment = "代码复杂度"
outcome = "缺陷数量"
confounders = ["开发经验", "项目规模", "时间压力"]

estimate, refute = discover_causal_effects(data, treatment, outcome, confounders)
print(f"因果效应估计: {estimate.value}")
print(f"反驳结果: {refute}")

import networkx as nx
from typing import Dict, List

class DUCGNetwork:
    """DUCG网络类"""
    
    def __init__(self, name):
        self.name = name
        self.variables = {}      # 变量字典
        self.graph = nx.DiGraph()  # 有向图
        self.time_slices = 1     # 时间片数量（动态网络）
    
    def add_variable(self, variable: DUCGVariable):
        """添加变量节点"""
        self.variables[variable.name] = variable
        self.graph.add_node(variable.name, var_obj=variable)
    
    def add_edge(self, parent_name, child_name, strength=None, probability=None):
        """添加因果边"""
        if parent_name not in self.variables or child_name not in self.variables:
            raise ValueError("变量不存在")
        
        parent = self.variables[parent_name]
        child = self.variables[child_name]
        
        # 更新变量关系
        child.add_parent(parent)
        
        # 添加边到图
        self.graph.add_edge(
            parent_name,
            child_name,
            strength=strength,
            probability=probability
        )
    
    def set_causal_strength(self, parent_name, child_name, strength):
        """设置因果强度"""
        self.graph[parent_name][child_name]['strength'] = strength
        self.variables[child_name].set_causal_strength(
            self.variables[parent_name], 
            strength
        )
    
    def set_conditional_probability(self, variable_name, parent_states, probability):
        """设置条件概率"""
        var = self.variables[variable_name]
        var.probability[tuple(parent_states)] = probability
    
    def visualize(self, layout='spring', figsize=(12, 8)):
        """可视化DUCG网络"""
        import matplotlib.pyplot as plt
        
        plt.figure(figsize=figsize)
        
        # 选择布局
        if layout == 'spring':
            pos = nx.spring_layout(self.graph, k=2, iterations=50)
        elif layout == 'hierarchical':
            pos = nx.nx_agraph.graphviz_layout(self.graph, prog='dot')
        else:
            pos = nx.circular_layout(self.graph)
        
        # 节点颜色映射
        color_map = {
            VariableType.ROOT_CAUSE: 'lightcoral',
            VariableType.INTERMEDIATE: 'lightblue',
            VariableType.OBSERVABLE: 'lightgreen',
            VariableType.TARGET: 'gold'
        }
        
        node_colors = [
            color_map[self.variables[node].var_type] 
            for node in self.graph.nodes()
        ]
        
        # 绘制网络
        nx.draw(
            self.graph,
            pos,
            with_labels=True,
            node_color=node_colors,
            node_size=3000,
            font_size=10,
            font_weight='bold',
            arrows=True,
            arrowsize=20,
            edge_color='gray',
            width=2
        )
        
        # 添加边标签（因果强度）
        edge_labels = {}
        for u, v, data in self.graph.edges(data=True):
            if 'strength' in data and data['strength'] is not None:
                edge_labels[(u, v)] = f"{data['strength']:.2f}"
        
        nx.draw_networkx_edge_labels(
            self.graph,
            pos,
            edge_labels,
            font_size=8
        )
        
        plt.title(f'DUCG Network: {self.name}', fontsize=16, fontweight='bold')
        plt.axis('off')
        plt.tight_layout()
        plt.show()
    
    def get_markov_blanket(self, variable_name):
        """获取变量的马尔可夫毯"""
        var = self.variables[variable_name]
        
        # 马尔可夫毯 = 父节点 + 子节点 + 子节点的其他父节点
        mb = set(var.parents)
        mb.update(var.children)
        
        for child in var.children:
            mb.update(child.parents)
        
        mb.discard(var)  # 移除自己
        return list(mb)
    
    def to_dict(self):
        """导出为字典格式"""
        network_dict = {
            'name': self.name,
            'variables': [],
            'edges': []
        }
        
        for var_name, var in self.variables.items():
            network_dict['variables'].append({
                'name': var.name,
                'type': var.var_type.value,
                'state_type': var.state_type.value,
                'states': var.states
            })
        
        for u, v, data in self.graph.edges(data=True):
            network_dict['edges'].append({
                'from': u,
                'to': v,
                'strength': data.get('strength'),
                'probability': data.get('probability')
            })
        
        return network_dict
    
    def save_to_json(self, filepath):
        """保存为JSON文件"""
        import json
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(self.to_dict(), f, ensure_ascii=False, indent=2)
    
    @classmethod
    def load_from_json(cls, filepath):
        """从JSON文件加载"""
        import json
        with open(filepath, 'r', encoding='utf-8') as f:
            data = json.load(f)
        
        network = cls(data['name'])
        
        # 重建变量
        for var_data in data['variables']:
            var = DUCGVariable(
                name=var_data['name'],
                var_type=VariableType(var_data['type']),
                state_type=VariableState(var_data['state_type']),
                states=var_data.get('states')
            )
            network.add_variable(var)
        
        # 重建边
        for edge_data in data['edges']:
            network.add_edge(
                edge_data['from'],
                edge_data['to'],
                strength=edge_data.get('strength'),
                probability=edge_data.get('probability')
            )
        
        return network

# 创建DUCG网络
ducg_net = DUCGNetwork("软件缺陷诊断系统")

# 添加所有变量
ducg_net.add_variable(defect_logic_error)
ducg_net.add_variable(defect_memory_leak)
ducg_net.add_variable(defect_concurrency)
ducg_net.add_variable(symptom_crash)
ducg_net.add_variable(symptom_slow_performance)
ducg_net.add_variable(symptom_memory_usage)
ducg_net.add_variable(obs_test_failure)
ducg_net.add_variable(obs_code_coverage)
ducg_net.add_variable(obs_exception_count)
ducg_net.add_variable(target_defect_severity)

# 建立因果边及强度
# 逻辑错误 -> 症状
ducg_net.add_edge("逻辑错误", "程序崩溃", strength=0.7)
ducg_net.add_edge("逻辑错误", "测试失败率", strength=0.8)

# 内存泄漏 -> 症状
ducg_net.add_edge("内存泄漏", "内存占用异常", strength=0.9)
ducg_net.add_edge("内存泄漏", "性能下降", strength=0.6)

# 并发问题 -> 症状
ducg_net.add_edge("并发问题", "程序崩溃", strength=0.5)
ducg_net.add_edge("并发问题", "性能下降", strength=0.7)

# 症状 -> 可观测
ducg_net.add_edge("程序崩溃", "异常数量", strength=0.85)
ducg_net.add_edge("性能下降", "代码覆盖率", strength=0.4)
ducg_net.add_edge("内存占用异常", "性能下降", strength=0.6)

# 汇聚到目标
ducg_net.add_edge("测试失败率", "缺陷严重程度", strength=0.7)
ducg_net.add_edge("异常数量", "缺陷严重程度", strength=0.8)

# 可视化网络
ducg_net.visualize(layout='hierarchical')

import numpy as np
from sklearn.linear_model import LogisticRegression

def learn_causal_strength(data, cause_var, effect_var):
    """
    从数据中学习因果强度
    使用逻辑回归估计因果效应
    """
    X = data[[cause_var]].values
    y = data[effect_var].values
    
    # 训练逻辑回归模型
    model = LogisticRegression()
    model.fit(X, y)
    
    # 因果强度 = 回归系数的归一化值
    coefficient = model.coef_[0][0]
    strength = 1 / (1 + np.exp(-coefficient))  # Sigmoid归一化到[0,1]
    
    return strength

# 批量学习所有边的强度
def learn_all_strengths(ducg_network, data):
    """学习网络中所有边的因果强度"""
    for parent, child in ducg_network.graph.edges():
        strength = learn_causal_strength(data, parent, child)
        ducg_network.set_causal_strength(parent, child, strength)
        print(f"{parent} -> {child}: 强度 = {strength:.3f}")

# 使用示例
data = pd.read_csv('defect_data.csv')
learn_all_strengths(ducg_net, data)

def calibrate_with_expert_knowledge(learned_strength, expert_strength, 
                                   data_confidence, expert_confidence):
    """
    融合数据学习的强度和专家给出的强度
    使用贝叶斯加权平均
    """
    total_confidence = data_confidence + expert_confidence
    
    calibrated_strength = (
        (learned_strength * data_confidence + 
         expert_strength * expert_confidence) / 
        total_confidence
    )
    
    return calibrated_strength

# 示例：校准"内存泄漏 -> 内存占用异常"的强度
learned = 0.85
expert = 0.90
calibrated = calibrate_with_expert_knowledge(
    learned, expert,
    data_confidence=0.7,
    expert_confidence=0.9
)
print(f"校准后的因果强度: {calibrated:.3f}")

def estimate_cpt(data, variable, parent_variables):
    """
    估计条件概率表
    P(Variable | Parents)
    """
    if not parent_variables:
        # 无父节点，估计先验概率
        return data[variable].value_counts(normalize=True).to_dict()
    
    # 有父节点，估计条件概率
    cpt = {}
    
    # 枚举所有父节点状态组合
    parent_states = [data[p].unique() for p in parent_variables]
    
    from itertools import product
    for states in product(*parent_states):
        # 筛选满足父节点状态的数据
        mask = True
        for p, state in zip(parent_variables, states):
            mask &= (data[p] == state)
        
        subset = data[mask]
        
        if len(subset) > 0:
            # 计算条件概率
            prob_dist = subset[variable].value_counts(normalize=True).to_dict()
            cpt[states] = prob_dist
        else:
            # 数据稀疏，使用均匀分布
            var_states = data[variable].unique()
            cpt[states] = {s: 1.0/len(var_states) for s in var_states}
    
    return cpt

# 示例：估计"缺陷严重程度"的CPT
parents = ["测试失败率", "异常数量"]
cpt = estimate_cpt(data, "缺陷严重程度", parents)

print("条件概率表:")
for parent_states, probs in cpt.items():
    print(f"  给定父状态 {parent_states}:")
    for var_state, prob in probs.items():
        print(f"    P(缺陷严重程度={var_state}) = {prob:.3f}")

def bayesian_cpt_estimation(data, variable, parent_variables, prior_strength=1.0):
    """
    使用贝叶斯估计处理数据稀疏问题
    添加伪计数（Laplace平滑）
    """
    cpt = {}
    var_states = data[variable].unique()
    n_states = len(var_states)
    
    parent_states = [data[p].unique() for p in parent_variables]
    
    from itertools import product
    for states in product(*parent_states):
        mask = True
        for p, state in zip(parent_variables, states):
            mask &= (data[p] == state)
        
        subset = data[mask]
        
        # 计算计数 + 伪计数
        counts = subset[variable].value_counts().to_dict()
        
        total_count = len(subset) + prior_strength * n_states
        
        prob_dist = {}
        for var_state in var_states:
            count = counts.get(var_state, 0)
            # 贝叶斯估计
            prob_dist[var_state] = (count + prior_strength) / total_count
        
        cpt[states] = prob_dist
    
    return cpt

from sklearn.model_selection import KFold

def cross_validate_ducg(ducg_network, data, n_folds=5):
    """
    交叉验证DUCG模型
    """
    kf = KFold(n_splits=n_folds, shuffle=True, random_state=42)
    
    accuracies = []
    
    for train_idx, test_idx in kf.split(data):
        train_data = data.iloc[train_idx]
        test_data = data.iloc[test_idx]
        
        # 在训练集上学习参数
        learn_all_strengths(ducg_network, train_data)
        
        # 在测试集上评估
        predictions = []
        actuals = []
        
        for _, row in test_data.iterrows():
            evidence = row.to_dict()
            prediction = ducg_network.infer(evidence, target="缺陷严重程度")
            predictions.append(prediction)
            actuals.append(row["缺陷严重程度"])
        
        # 计算准确率
        accuracy = np.mean(np.array(predictions) == np.array(actuals))
        accuracies.append(accuracy)
    
    return {
        'mean_accuracy': np.mean(accuracies),
        'std_accuracy': np.std(accuracies),
        'fold_accuracies': accuracies
    }

# 使用示例
cv_results = cross_validate_ducg(ducg_net, data)
print(f"交叉验证准确率: {cv_results['mean_accuracy']:.3f} ± {cv_results['std_accuracy']:.3f}")

def sensitivity_analysis(ducg_network, variable, evidence, delta=0.1):
    """
    分析变量对推理结果的敏感性
    """
    baseline_result = ducg_network.infer(evidence)
    
    sensitivities = {}
    
    for var_name in ducg_network.variables.keys():
        if var_name == variable:
            continue
        
        # 扰动变量概率
        perturbed_evidence = evidence.copy()
        
        # 这里简化处理：假设变量为二值
        original_value = evidence.get(var_name)
        
        if original_value is not None:
            # 翻转值
            perturbed_value = not original_value
            perturbed_evidence[var_name] = perturbed_value
            
            perturbed_result = ducg_network.infer(perturbed_evidence)
            
            # 计算结果变化
            sensitivity = abs(perturbed_result - baseline_result)
            sensitivities[var_name] = sensitivity
    
    # 排序
    sorted_sensitivities = sorted(
        sensitivities.items(),
        key=lambda x: x[1],
        reverse=True
    )
    
    return sorted_sensitivities

# 使用示例
evidence = {
    "测试失败率": "高",
    "代码覆盖率": "低",
    "异常数量": "多"
}

sensitivities = sensitivity_analysis(ducg_net, "缺陷严重程度", evidence)
print("敏感性分析结果:")
for var, sens in sensitivities[:5]:
    print(f"  {var}: {sens:.4f}")

def compare_models(models, test_data, metrics=['accuracy', 'f1', 'auc']):
    """
    比较多个DUCG模型
    """
    results = {}
    
    for model_name, model in models.items():
        results[model_name] = {}
        
        predictions = []
        actuals = []
        probabilities = []
        
        for _, row in test_data.iterrows():
            evidence = row.to_dict()
            pred = model.infer(evidence, target="缺陷严重程度")
            prob = model.infer_probability(evidence, target="缺陷严重程度")
            
            predictions.append(pred)
            actuals.append(row["缺陷严重程度"])
            probabilities.append(prob)
        
        # 计算指标
        from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
        
        results[model_name]['accuracy'] = accuracy_score(actuals, predictions)
        results[model_name]['f1'] = f1_score(actuals, predictions, average='weighted')
        
        # 如果是二分类，计算AUC
        if len(set(actuals)) == 2:
            results[model_name]['auc'] = roc_auc_score(actuals, probabilities)
    
    return results

# 可视化比较
def visualize_model_comparison(results):
    import matplotlib.pyplot as plt
    
    models = list(results.keys())
    metrics = list(results[models[0]].keys())
    
    x = np.arange(len(models))
    width = 0.25
    
    fig, ax = plt.subplots(figsize=(10, 6))
    
    for i, metric in enumerate(metrics):
        values = [results[m][metric] for m in models]
        ax.bar(x + i * width, values, width, label=metric)
    
    ax.set_xlabel('模型')
    ax.set_ylabel('分数')
    ax.set_title('模型性能比较')
    ax.set_xticks(x + width)
    ax.set_xticks(models)
    ax.legend()
    
    plt.tight_layout()
    plt.show()

class DUCGInferenceEngine:
    """DUCG推理引擎"""
    
    def __init__(self, network: DUCGNetwork):
        self.network = network
    
    def infer(self, evidence: Dict, target: str, method='weighted'):
        """
        执行推理
        
        参数:
            evidence: 观测证据字典 {'变量名': 值}
            target: 目标变量名
            method: 推理方法 ('weighted', 'max', 'monte_carlo')
        
        返回:
            最可能的目标状态
        """
        if method == 'weighted':
            return self._weighted_inference(evidence, target)
        elif method == 'max':
            return self._max_inference(evidence, target)
        else:
            return self._monte_carlo_inference(evidence, target)
    
    def _weighted_inference(self, evidence, target):
        """加权推理（DUCG特有方法）"""
        target_var = self.network.variables[target]
        
        # 收集所有影响目标的路径
        paths = self._find_all_paths(evidence, target)
        
        # 计算每条路径的加权值
        state_scores = {}
        for state in target_var.states:
            score = 0
            for path, strength in paths:
                # 路径强度 = 所有边强度的乘积
                path_strength = np.prod([
                    self.network.graph[u][v]['strength']
                    for u, v in zip(path[:-1], path[1:])
                ])
                
                # 考虑证据的影响
                evidence_support = self._evaluate_evidence_support(path, evidence, state)
                
                score += path_strength * strength * evidence_support
            
            state_scores[state] = score
        
        # 返回得分最高的状态
        return max(state_scores, key=state_scores.get)
    
    def _find_all_paths(self, evidence, target):
        """找到从证据节点到目标节点的所有路径"""
        import networkx as nx
        
        paths = []
        for evidence_var in evidence.keys():
            if evidence_var in self.network.graph:
                try:
                    all_paths = nx.all_simple_paths(
                        self.network.graph,
                        source=evidence_var,
                        target=target,
                        cutoff=5  # 最大路径长度
                    )
                    paths.extend(list(all_paths))
                except nx.NetworkXNoPath:
                    continue
        
        return [(path, 1.0) for path in paths]
    
    def _evaluate_evidence_support(self, path, evidence, target_state):
        """评估证据对目标状态的支持度"""
        support = 1.0
        
        for node in path:
            if node in evidence:
                # 简化：如果证据为True，支持度为1，否则为0.1
                if evidence[node]:
                    support *= 1.0
                else:
                    support *= 0.1
        
        return support
    
    def infer_probability(self, evidence, target):
        """推理目标变量的概率分布"""
        target_var = self.network.variables[target]
        
        # 使用近似推理（变量消除或信念传播）
        probs = {}
        
        for state in target_var.states:
            # 简化：基于因果强度和证据计算概率
            prob = self._calculate_state_probability(evidence, target, state)
            probs[state] = prob
        
        # 归一化
        total = sum(probs.values())
        probs = {k: v/total for k, v in probs.items()}
        
        return probs
    
    def _calculate_state_probability(self, evidence, target, state):
        """计算特定状态的概率"""
        # 这里使用简化的计算方式
        # 实际应用中应使用更精确的概率推理算法
        target_var = self.network.variables[target]
        
        # 基础概率（先验）
        base_prob = 1.0 / len(target_var.states)
        
        # 根据父节点证据调整
        for parent in target_var.parents:
            if parent.name in evidence:
                parent_state = evidence[parent.name]
                # 查找条件概率
                cpt_key = (parent_state,)
                if cpt_key in target_var.probability:
                    cond_prob = target_var.probability[cpt_key].get(state, base_prob)
                    base_prob *= cond_prob
        
        return base_prob
    
    def explain(self, evidence, target, result):
        """解释推理结果"""
        explanation = []
        
        # 找到支持该结果的关键证据
        target_var = self.network.variables[target]
        
        # 分析各证据的贡献
        contributions = {}
        for ev_var, ev_value in evidence.items():
            # 计算移除该证据后结果的变化
            temp_evidence = evidence.copy()
            del temp_evidence[ev_var]
            
            new_result = self.infer(temp_evidence, target)
            
            if new_result != result:
                contributions[ev_var] = "关键"
            else:
                contributions[ev_var] = "次要"
        
        explanation.append(f"诊断结果: {target} = {result}")
        explanation.append("\n证据分析:")
        
        for ev_var, contribution in contributions.items():
            explanation.append(
                f"  - {ev_var} = {evidence[ev_var]} ({contribution}证据)"
            )
        
        # 分析因果路径
        explanation.append("\n关键因果路径:")
        paths = self._find_all_paths(evidence, target)
        
        for i, (path, _) in enumerate(paths[:3], 1):
            path_str = " -> ".join(path)
            explanation.append(f"  {i}. {path_str}")
        
        return "\n".join(explanation)

# 使用示例
engine = DUCGInferenceEngine(ducg_net)

# 推理
evidence = {
    "测试失败率": "高",
    "异常数量": "多",
    "代码覆盖率": "低"
}

result = engine.infer(evidence, target="缺陷严重程度")
print(f"诊断结果: {result}")

# 概率分布
probs = engine.infer_probability(evidence, target="缺陷严重程度")
print("\n概率分布:")
for state, prob in probs.items():
    print(f"  P(缺陷严重程度={state}) = {prob:.3f}")

# 解释
explanation = engine.explain(evidence, "缺陷严重程度", result)
print("\n" + explanation)

from flask import Flask, request, jsonify
import json

app = Flask(__name__)

# 加载训练好的DUCG网络
ducg_network = DUCGNetwork.load_from_json('trained_ducg_model.json')
inference_engine = DUCGInferenceEngine(ducg_network)

@app.route('/api/diagnose', methods=['POST'])
def diagnose():
    """诊断API"""
    try:
        # 解析输入
        data = request.get_json()
        evidence = data.get('evidence', {})
        target = data.get('target', '缺陷严重程度')
        
        # 执行推理
        result = inference_engine.infer(evidence, target)
        probs = inference_engine.infer_probability(evidence, target)
        explanation = inference_engine.explain(evidence, target, result)
        
        # 返回结果
        return jsonify({
            'success': True,
            'result': result,
            'probabilities': probs,
            'explanation': explanation
        })
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/model/info', methods=['GET'])
def model_info():
    """模型信息API"""
    return jsonify({
        'name': ducg_network.name,
        'num_variables': len(ducg_network.variables),
        'num_edges': len(ducg_network.graph.edges()),
        'variables': list(ducg_network.variables.keys())
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)

import requests

# 诊断请求
response = requests.post(
    'http://localhost:5000/api/diagnose',
    json={
        'evidence': {
            '测试失败率': '高',
            '异常数量': '多',
            '代码覆盖率': '低'
        },
        'target': '缺陷严重程度'
    }
)

result = response.json()
print(f"诊断结果: {result['result']}")
print(f"解释: {result['explanation']}")