智能调试与错误预测的未来_02

import os
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from sklearn.preprocessing import StandardScaler
import pickle
from sklearn.feature_selection import SelectFromModel

# 设置中文字体
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams["axes.unicode_minus"] = False  # 解决负号显示问题

def load_data(file_path):
    """加载代码度量和缺陷数据"""
    try:
        data = pd.read_csv(file_path)
        print(f"数据加载成功，共 {data.shape[0]} 行，{data.shape[1]} 列")
        return data
    except Exception as e:
        print(f"加载数据时出错: {e}")
        return None

def preprocess_data(data):
    """数据预处理"""
    # 假设最后一列是目标变量（是否有缺陷）
    X = data.iloc[:, :-1]
    y = data.iloc[:, -1]
    
    # 数据标准化
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # 特征选择
    selector = SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42))
    X_selected = selector.fit_transform(X_scaled, y)
    
    # 获取选中的特征名称
    selected_features = X.columns[selector.get_support()]
    print(f"选中的特征: {list(selected_features)}")
    
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(
        X_selected, y, test_size=0.3, random_state=42, stratify=y
    )
    
    return X_train, X_test, y_train, y_test, scaler, selector, selected_features

def train_model(X_train, y_train):
    """训练错误预测模型"""
    # 定义参数网格
    param_grid = {
        'n_estimators': [100, 200, 300],
        'max_depth': [None, 10, 20, 30],
        'min_samples_split': [2, 5, 10],
        'min_samples_leaf': [1, 2, 4]
    }
    
    # 使用网格搜索寻找最佳参数
    grid_search = GridSearchCV(
        estimator=RandomForestClassifier(random_state=42),
        param_grid=param_grid,
        cv=5,
        scoring='f1',  # 使用F1分数作为评估指标，平衡精确率和召回率
        n_jobs=-1,
        verbose=1
    )
    
    # 训练模型
    grid_search.fit(X_train, y_train)
    
    print(f"最佳参数: {grid_search.best_params_}")
    print(f"最佳交叉验证分数: {grid_search.best_score_:.4f}")
    
    # 返回最佳模型
    return grid_search.best_estimator_

def evaluate_model(model, X_test, y_test):
    """评估模型性能"""
    # 预测
    y_pred = model.predict(X_test)
    y_pred_proba = model.predict_proba(X_test)[:, 1]  # 获取正类的概率
    
    # 计算准确率
    accuracy = accuracy_score(y_test, y_pred)
    print(f"测试集准确率: {accuracy:.4f}")
    
    # 生成分类报告
    print("分类报告:")
    print(classification_report(y_test, y_pred))
    
    # 生成混淆矩阵
    cm = confusion_matrix(y_test, y_pred)
    print("混淆矩阵:")
    print(cm)
    
    # 可视化混淆矩阵
    plt.figure(figsize=(8, 6))
    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
    plt.title('混淆矩阵')
    plt.colorbar()
    classes = ['无缺陷', '有缺陷']
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes)
    plt.yticks(tick_marks, classes)
    
    # 在混淆矩阵上标注数值
    thresh = cm.max() / 2.
    for i, j in np.ndindex(cm.shape):
        plt.text(j, i, format(cm[i, j], 'd'),
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")
    
    plt.ylabel('真实标签')
    plt.xlabel('预测标签')
    plt.tight_layout()
    plt.savefig('confusion_matrix.png')
    plt.close()
    
    return y_pred, y_pred_proba

def feature_importance_analysis(model, feature_names):
    """分析特征重要性"""
    # 获取特征重要性
    importances = model.feature_importances_
    
    # 创建特征重要性DataFrame
    feature_importance_df = pd.DataFrame({
        'Feature': feature_names,
        'Importance': importances
    })
    
    # 按重要性排序
    feature_importance_df = feature_importance_df.sort_values('Importance', ascending=False)
    
    # 打印特征重要性
    print("特征重要性:")
    print(feature_importance_df)
    
    # 可视化特征重要性
    plt.figure(figsize=(10, 6))
    plt.barh(feature_importance_df['Feature'], feature_importance_df['Importance'])
    plt.xlabel('重要性')
    plt.ylabel('特征')
    plt.title('错误预测模型的特征重要性')
    plt.tight_layout()
    plt.savefig('feature_importance.png')
    plt.close()
    
    return feature_importance_df

def save_model(model, scaler, selector, file_path='error_prediction_model.pkl'):
    """保存模型和预处理组件"""
    try:
        with open(file_path, 'wb') as f:
            pickle.dump({
                'model': model,
                'scaler': scaler,
                'selector': selector
            }, f)
        print(f"模型已保存至: {file_path}")
    except Exception as e:
        print(f"保存模型时出错: {e}")

def predict_new_code(model, scaler, selector, code_metrics):
    """预测新代码是否有缺陷"""
    try:
        # 数据预处理
        scaled_metrics = scaler.transform([code_metrics])
        selected_metrics = selector.transform(scaled_metrics)
        
        # 预测
        prediction = model.predict(selected_metrics)[0]
        probability = model.predict_proba(selected_metrics)[0][1]
        
        return prediction, probability
    except Exception as e:
        print(f"预测时出错: {e}")
        return None, None

# 示例使用
if __name__ == "__main__":
    # 注意：在实际使用时，需要替换为真实的代码度量数据集
    # 这里我们创建一个模拟数据集用于演示
    def create_sample_data():
        """创建样本数据"""
        np.random.seed(42)
        
        # 生成代码度量数据
        n_samples = 1000
        
        # 假设我们有以下代码度量指标
        complexity = np.random.randint(1, 50, size=n_samples)  # 圈复杂度
        loc = np.random.randint(10, 500, size=n_samples)  # 代码行数
        comment_ratio = np.random.uniform(0, 0.5, size=n_samples)  # 注释率
        coupling = np.random.randint(1, 20, size=n_samples)  # 耦合度
        inheritance_depth = np.random.randint(1, 10, size=n_samples)  # 继承深度
        
        # 基于度量指标生成缺陷标签（有一定的随机性）
        # 复杂度高、行数多、耦合度高的代码更容易有缺陷
        defect_probability = (
            0.02 * complexity + 
            0.001 * loc + 
            0.1 * coupling - 
            0.2 * comment_ratio
        ) / 3
        
        # 添加随机噪声
        defect_probability = np.clip(defect_probability + np.random.normal(0, 0.1, size=n_samples), 0, 1)
        
        # 根据概率生成缺陷标签
        defects = np.random.binomial(1, defect_probability)
        
        # 创建DataFrame
        data = pd.DataFrame({
            'complexity': complexity,
            'loc': loc,
            'comment_ratio': comment_ratio,
            'coupling': coupling,
            'inheritance_depth': inheritance_depth,
            'defect': defects
        })
        
        return data
    
    # 创建样本数据
    sample_data = create_sample_data()
    
    # 数据预处理
    X_train, X_test, y_train, y_test, scaler, selector, selected_features = preprocess_data(sample_data)
    
    # 训练模型
    print("\n开始训练错误预测模型...")
    model = train_model(X_train, y_train)
    
    # 评估模型
    print("\n评估模型性能...")
    y_pred, y_pred_proba = evaluate_model(model, X_test, y_test)
    
    # 特征重要性分析
    print("\n分析特征重要性...")
    feature_importance_df = feature_importance_analysis(model, selected_features)
    
    # 保存模型
    save_model(model, scaler, selector)
    
    # 示例预测新代码
    print("\n预测新代码示例...")
    # 假设有一段新代码的度量指标
    new_code_metrics = [35, 300, 0.1, 15, 5]  # complexity, loc, comment_ratio, coupling, inheritance_depth
    prediction, probability = predict_new_code(model, scaler, selector, new_code_metrics)
    
    if prediction is not None:
        result = "有缺陷" if prediction == 1 else "无缺陷"
        print(f"新代码预测结果: {result} (概率: {probability:.4f})")
    
    print("\n错误预测模型演示完成！")