← 返回列表

[智能体攻防实战] 二.CodeBuddy赋能恶意代码分析与家族分类实践

单站 娜璋AI安全之家 发布 Wed, 17 Jun 2026 10:18:00 +0800 入库 2026-11-18T12:26:06

原创 Eastmount 2026-06-17 10:18 贵州

智能体攻防实战第二篇介绍恶意代码分析与家族分类,希望您喜欢!

import pandas as pd

import numpy as np

import os

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

# 设置中文字体

plt.rcParams['font.sans-serif'] = ['SimHei']

plt.rcParams['axes.unicode_minus'] = False

# 读取数据文件夹中的所有CSV文件

data_dir = 'c:/Users/xiuzhang/Desktop/mal_analysis/data'

csv_files = [os.path.join(data_dir, f) for f in os.listdir(data_dir) if f.endswith('.csv') and 'result_final' in f]

print("=" * 80)

print("步骤1: 读取并合并所有CSV文件")

print("=" * 80)

# 读取所有CSV文件

dfs = []

sample_counts = {}

total_before_clean = 0

total_after_clean = 0

for csv_file in csv_files:

file_name = os.path.basename(csv_file)

df = pd.read_csv(csv_file)

# 清理数据:删除label为NaN的行

before_clean = len(df)

df_cleaned = df.dropna(subset=['label'])

after_clean = len(df_cleaned)

sample_counts[file_name] = len(df_cleaned)

dfs.append(df_cleaned)

total_before_clean += before_clean

total_after_clean += after_clean

print(f"读取文件: {file_name}")

print(f"  原始样本数量: {before_clean}")

print(f"  清理后样本数量: {after_clean}")

print(f"  删除的NaN行数: {before_clean - after_clean}")

# 合并所有数据集

merged_df = pd.concat(dfs, ignore_index=True)

print(f"\n合并后总样本数量: {len(merged_df)}")

print(f"合并前各文件样本数量之和: {sum(sample_counts.values())}")

print(f"合并前后样本数量是否一致: {len(merged_df) == sum(sample_counts.values())}")

print(f"\n【数据清理统计】")

print(f"清理前总样本数: {total_before_clean}")

print(f"清理后总样本数: {total_after_clean}")

print(f"删除的无效行数: {total_before_clean - total_after_clean}")

print(f"保留率: {total_after_clean/total_before_clean*100:.2f}%")

# 移除样本数量过少的类别(样本数量小于10的类别)

label_counts = merged_df['label'].value_counts()

valid_labels = label_counts[label_counts >= 10].index

merged_df = merged_df[merged_df['label'].isin(valid_labels)]

print(f"\n【类别过滤】")

print(f"原始标签类别数: {len(label_counts)}")

print(f"保留的标签类别数: {len(valid_labels)}")

print(f"移除的标签类别数: {len(label_counts) - len(valid_labels)}")

print(f"过滤后样本数量: {len(merged_df)}")

# 保存合并后的数据集

output_dir = 'c:/Users/xiuzhang/Desktop/mal_analysis/processed'

os.makedirs(output_dir, exist_ok=True)

merged_df.to_csv(os.path.join(output_dir, 'merged_dataset.csv'), index=False)

print(f"\n合并后的数据集已保存至: {os.path.join(output_dir, 'merged_dataset.csv')}")

print("\n" + "=" * 80)

print("步骤2: 按照6:3:1比例划分数据集")

print("=" * 80)

# 首先打乱数据

merged_df_shuffled = merged_df.sample(frac=1, random_state=42).reset_index(drop=True)

# 按照6:3:1的比例划分

# 6:3:1 = 60%:30%:10%

train_ratio = 0.6

val_ratio = 0.3

test_ratio = 0.1

# 第一次划分: 训练集 + 临时集

train_df, temp_df = train_test_split(

merged_df_shuffled,

test_size=(val_ratio + test_ratio),

random_state=42,

stratify=merged_df_shuffled['label']

)

# 第二次划分: 从临时集中划分验证集和测试集

val_df, test_df = train_test_split(

temp_df,

test_size=(test_ratio / (val_ratio + test_ratio)),  # 0.1 / (0.3 + 0.1) = 0.25

random_state=42,

stratify=temp_df['label']

)

print(f"训练集样本数量: {len(train_df)} ({len(train_df)/len(merged_df)*100:.1f}%)")

print(f"验证集样本数量: {len(val_df)} ({len(val_df)/len(merged_df)*100:.1f}%)")

print(f"测试集样本数量: {len(test_df)} ({len(test_df)/len(merged_df)*100:.1f}%)")

print(f"总计: {len(train_df) + len(val_df) + len(test_df)}")

print(f"划分前后样本数量是否一致: {len(merged_df) == len(train_df) + len(val_df) + len(test_df)}")

# 保存划分后的数据集

train_df.to_csv(os.path.join(output_dir, 'train_dataset.csv'), index=False)

val_df.to_csv(os.path.join(output_dir, 'val_dataset.csv'), index=False)

test_df.to_csv(os.path.join(output_dir, 'test_dataset.csv'), index=False)

print(f"\n训练集已保存至: {os.path.join(output_dir, 'train_dataset.csv')}")

print(f"验证集已保存至: {os.path.join(output_dir, 'val_dataset.csv')}")

print(f"测试集已保存至: {os.path.join(output_dir, 'test_dataset.csv')}")

print("\n" + "=" * 80)

print("步骤3: 统计分析数据集分布情况")

print("=" * 80)

# 3.1 标签分布统计

print("\n【合并数据集标签分布】")

label_distribution = merged_df['label'].value_counts().sort_index()

print(label_distribution)

print(f"\n标签数量: {len(label_distribution)}")

print(f"样本总数: {len(merged_df)}")

# 3.2 各数据集的标签分布

print("\n【训练集标签分布】")

train_label_dist = train_df['label'].value_counts().sort_index()

print(train_label_dist)

print("\n【验证集标签分布】")

val_label_dist = val_df['label'].value_counts().sort_index()

print(val_label_dist)

print("\n【测试集标签分布】")

test_label_dist = test_df['label'].value_counts().sort_index()

print(test_label_dist)

# 3.3 原始文件统计

print("\n【原始CSV文件样本统计】")

print(f"文件名{' '*20}样本数量")

print("-" * 40)

for file_name, count in sorted(sample_counts.items()):

print(f"{file_name:30s}{count:>10}")

print("\n" + "=" * 80)

print("步骤4: 绘制可视化图表")

print("=" * 80)

# 创建可视化图表保存目录

pic_dir = 'c:/Users/xiuzhang/Desktop/mal_analysis/pic/analysis'

os.makedirs(pic_dir, exist_ok=True)

# 4.1 原始文件样本数量分布

plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)

sorted_files = sorted(sample_counts.items(), key=lambda x: x[0])

file_names = [item[0] for item in sorted_files]

file_counts = [item[1] for item in sorted_files]

colors = plt.cm.Set3(range(len(file_names)))

bars = plt.bar(file_names, file_counts, color=colors)

plt.xlabel('恶意家族文件', fontsize=12)

plt.ylabel('样本数量', fontsize=12)

plt.title('各恶意家族样本数量分布', fontsize=14, fontweight='bold')

plt.xticks(rotation=45, ha='right')

# 添加数值标签

for bar in bars:

height = bar.get_height()

plt.text(bar.get_x() + bar.get_width()/2., height,

f'{int(height)}',

ha='center', va='bottom', fontsize=9)

plt.grid(axis='y', alpha=0.3)

# 4.2 合并数据集标签分布

plt.subplot(1, 2, 2)

label_names = label_distribution.index.tolist()

label_counts = label_distribution.values.tolist()

colors = plt.cm.Set2(range(len(label_names)))

bars = plt.bar(label_names, label_counts, color=colors)

plt.xlabel('标签类别', fontsize=12)

plt.ylabel('样本数量', fontsize=12)

plt.title('合并数据集标签分布', fontsize=14, fontweight='bold')

# 添加数值标签

for bar in bars:

height = bar.get_height()

plt.text(bar.get_x() + bar.get_width()/2., height,

f'{int(height)}',

ha='center', va='bottom', fontsize=10)

plt.grid(axis='y', alpha=0.3)

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '原始数据集分布.png'), dpi=300, bbox_inches='tight')

print(f"\n图表已保存至: {os.path.join(pic_dir, '原始数据集分布.png')}")

# 4.3 数据集划分后的标签分布对比

fig, axes = plt.subplots(1, 3, figsize=(18, 6))

datasets = [

('训练集', train_label_dist),

('验证集', val_label_dist),

('测试集', test_label_dist)

]

colors_set = plt.cm.Set2(range(len(label_names)))

for idx, (name, dist) in enumerate(datasets):

ax = axes[idx]

bars = ax.bar(dist.index, dist.values, color=colors_set)

ax.set_xlabel('标签类别', fontsize=12)

ax.set_ylabel('样本数量', fontsize=12)

ax.set_title(f'{name}标签分布', fontsize=14, fontweight='bold')

# 添加数值标签

for bar in bars:

height = bar.get_height()

ax.text(bar.get_x() + bar.get_width()/2., height,

f'{int(height)}',

ha='center', va='bottom', fontsize=10)

ax.grid(axis='y', alpha=0.3)

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '划分后数据集分布.png'), dpi=300, bbox_inches='tight')

print(f"图表已保存至: {os.path.join(pic_dir, '划分后数据集分布.png')}")

# 4.4 数据集划分比例对比

fig, ax = plt.subplots(figsize=(10, 6))

dataset_names = ['训练集', '验证集', '测试集']

dataset_sizes = [len(train_df), len(val_df), len(test_df)]

colors_pie = plt.cm.Pastel1([0, 1, 2])

wedges, texts, autotexts = ax.pie(dataset_sizes, labels=dataset_names, autopct='%1.1f%%',

colors=colors_pie, startangle=90, textprops={'fontsize': 12})

for autotext in autotexts:

autotext.set_fontsize(12)

autotext.set_fontweight('bold')

ax.set_title('数据集划分比例 (6:3:1)', fontsize=16, fontweight='bold', pad=20)

plt.savefig(os.path.join(pic_dir, '数据集划分比例.png'), dpi=300, bbox_inches='tight')

print(f"图表已保存至: {os.path.join(pic_dir, '数据集划分比例.png')}")

# 4.5 标签分布对比(所有数据集)

fig, ax = plt.subplots(figsize=(14, 8))

labels = sorted(list(set(train_label_dist.index) | set(val_label_dist.index) | set(test_label_dist.index)))

x = np.arange(len(labels))

width = 0.25

train_counts = [train_label_dist.get(label, 0) for label in labels]

val_counts = [val_label_dist.get(label, 0) for label in labels]

test_counts = [test_label_dist.get(label, 0) for label in labels]

bars1 = ax.bar(x - width, train_counts, width, label='训练集', color=colors_pie[0], alpha=0.8)

bars2 = ax.bar(x, val_counts, width, label='验证集', color=colors_pie[1], alpha=0.8)

bars3 = ax.bar(x + width, test_counts, width, label='测试集', color=colors_pie[2], alpha=0.8)

ax.set_xlabel('标签类别', fontsize=12)

ax.set_ylabel('样本数量', fontsize=12)

ax.set_title('各数据集标签分布对比', fontsize=14, fontweight='bold')

ax.set_xticks(x)

ax.set_xticklabels(labels)

ax.legend(fontsize=11)

ax.grid(axis='y', alpha=0.3)

# 添加数值标签

for bars in [bars1, bars2, bars3]:

for bar in bars:

height = bar.get_height()

if height > 0:

ax.text(bar.get_x() + bar.get_width()/2., height,

f'{int(height)}',

ha='center', va='bottom', fontsize=8)

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '各数据集标签分布对比.png'), dpi=300, bbox_inches='tight')

print(f"图表已保存至: {os.path.join(pic_dir, '各数据集标签分布对比.png')}")

# 4.6 数据集统计表格

fig, ax = plt.subplots(figsize=(12, 6))

ax.axis('tight')

ax.axis('off')

# 准备统计表格数据

table_data = []

table_data.append(['', '训练集', '验证集', '测试集', '总计'])

table_data.append(['样本数量', len(train_df), len(val_df), len(test_df), len(merged_df)])

table_data.append(['占比', f'{len(train_df)/len(merged_df)*100:.1f}%',

f'{len(val_df)/len(merged_df)*100:.1f}%',

f'{len(test_df)/len(merged_df)*100:.1f}%', '100.0%'])

# 添加各标签的统计

for label in sorted(merged_df['label'].unique()):

train_count = len(train_df[train_df['label'] == label])

val_count = len(val_df[val_df['label'] == label])

test_count = len(test_df[test_df['label'] == label])

table_data.append([f'标签{label}', train_count, val_count, test_count, train_count+val_count+test_count])

table = ax.table(cellText=table_data, cellLoc='center', loc='center')

table.auto_set_font_size(False)

table.set_fontsize(10)

table.scale(1.2, 1.5)

# 设置表头样式

for i in range(len(table_data[0])):

table[(0, i)].set_facecolor('#4472C4')

table[(0, i)].set_text_props(weight='bold', color='white')

# 设置第一列样式

for i in range(len(table_data)):

table[(i, 0)].set_facecolor('#D9E2F3')

plt.title('数据集统计汇总表', fontsize=14, fontweight='bold', pad=20)

plt.savefig(os.path.join(pic_dir, '数据集统计汇总表.png'), dpi=300, bbox_inches='tight')

print(f"图表已保存至: {os.path.join(pic_dir, '数据集统计汇总表.png')}")

print("\n" + "=" * 80)

print("数据处理完成!")

print("=" * 80)

print(f"\n所有处理后的文件保存在: {output_dir}")

print(f"所有可视化图表保存在: {pic_dir}")

print("\n生成文件列表:")

print("数据文件:")

print("  - merged_dataset.csv (合并后的完整数据集)")

print("  - train_dataset.csv (训练集)")

print("  - val_dataset.csv (验证集)")

print("  - test_dataset.csv (测试集)")

print("\n可视化图表:")

print("  - 原始数据集分布.png")

print("  - 划分后数据集分布.png")

print("  - 数据集划分比例.png")

print("  - 各数据集标签分布对比.png")

print("  - 数据集统计汇总表.png")

import pandas as pd

import numpy as np

import os

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.ensemble import RandomForestClassifier

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report

from sklearn.preprocessing import LabelEncoder

from sklearn.feature_extraction.text import TfidfVectorizer

import warnings

warnings.filterwarnings('ignore')

# 设置中文字体

plt.rcParams['font.sans-serif'] = ['SimHei']

plt.rcParams['axes.unicode_minus'] = False

print("=" * 80)

print("随机森林模型构建与评价")

print("=" * 80)

# 1. 读取数据

print("\n【步骤1: 读取数据】")

train_df = pd.read_csv('c:/Users/xiuzhang/Desktop/mal_analysis/processed/train_dataset.csv')

test_df = pd.read_csv('c:/Users/xiuzhang/Desktop/mal_analysis/processed/test_dataset.csv')

print(f"训练集样本数: {len(train_df)}")

print(f"测试集样本数: {len(test_df)}")

print(f"特征列: tactic, technique, tid, api, dynamic_api")

print(f"标签列: label")

# 2. 特征工程

print("\n【步骤2: 特征工程】")

# 定义特征列

feature_columns = ['tactic', 'technique', 'tid', 'api', 'dynamic_api']

# 检查缺失值

print("检查特征缺失值:")

for col in feature_columns:

train_nan = train_df[col].isna().sum()

test_nan = test_df[col].isna().sum()

print(f"  {col}: 训练集缺失 {train_nan}, 测试集缺失 {test_nan}")

# 填充缺失值

for col in feature_columns:

train_df[col] = train_df[col].fillna('')

test_df[col] = test_df[col].fillna('')

# 对每个文本特征使用TF-IDF编码

print("\n使用TF-IDF对文本特征进行编码...")

# 为每个特征创建TF-IDF向量化器

tactic_tfidf = TfidfVectorizer(max_features=100, token_pattern=r'(?u)\b\w+\b|;')

technique_tfidf = TfidfVectorizer(max_features=100, token_pattern=r'(?u)\b\w+\b|;')

tid_tfidf = TfidfVectorizer(max_features=50, token_pattern=r'(?u)\b\w+\b|;')

api_tfidf = TfidfVectorizer(max_features=200, token_pattern=r'(?u)\b\w+\b|;')

dynamic_api_tfidf = TfidfVectorizer(max_features=200, token_pattern=r'(?u)\b\w+\b|;')

# 训练集TF-IDF转换

train_tactic = tactic_tfidf.fit_transform(train_df['tactic'].astype(str)).toarray()

train_technique = technique_tfidf.fit_transform(train_df['technique'].astype(str)).toarray()

train_tid = tid_tfidf.fit_transform(train_df['tid'].astype(str)).toarray()

train_api = api_tfidf.fit_transform(train_df['api'].astype(str)).toarray()

train_dynamic_api = dynamic_api_tfidf.fit_transform(train_df['dynamic_api'].astype(str)).toarray()

# 测试集TF-IDF转换(使用训练集拟合的向量化器)

test_tactic = tactic_tfidf.transform(test_df['tactic'].astype(str)).toarray()

test_technique = technique_tfidf.transform(test_df['technique'].astype(str)).toarray()

test_tid = tid_tfidf.transform(test_df['tid'].astype(str)).toarray()

test_api = api_tfidf.transform(test_df['api'].astype(str)).toarray()

test_dynamic_api = dynamic_api_tfidf.transform(test_df['dynamic_api'].astype(str)).toarray()

# 拼接所有特征向量

X_train = np.hstack([train_tactic, train_technique, train_tid, train_api, train_dynamic_api])

X_test = np.hstack([test_tactic, test_technique, test_tid, test_api, test_dynamic_api])

print(f"训练集特征向量维度: {X_train.shape}")

print(f"测试集特征向量维度: {X_test.shape}")

print(f"特征维度分布: tactic(100) + technique(100) + tid(50) + api(200) + dynamic_api(200) = {X_train.shape[1]}")

# 3. 标签编码

print("\n【步骤3: 标签编码】")

label_encoder = LabelEncoder()

y_train = label_encoder.fit_transform(train_df['label'])

y_test = label_encoder.transform(test_df['label'])

print(f"标签类别: {label_encoder.classes_}")

print(f"标签数量: {len(label_encoder.classes_)}")

print(f"训练集标签分布: {np.bincount(y_train)}")

print(f"测试集标签分布: {np.bincount(y_test)}")

# 4. 构建随机森林模型

print("\n【步骤4: 构建随机森林模型】")

# 创建随机森林分类器

rf_model = RandomForestClassifier(

n_estimators=100,

max_depth=None,

min_samples_split=2,

min_samples_leaf=1,

max_features='sqrt',

random_state=42,

n_jobs=-1,

class_weight='balanced'

)

# 训练模型

print("开始训练随机森林模型...")

rf_model.fit(X_train, y_train)

print("模型训练完成!")

# 5. 模型预测

print("\n【步骤5: 模型预测】")

y_train_pred = rf_model.predict(X_train)

y_test_pred = rf_model.predict(X_test)

# 6. 性能评价

print("\n【步骤6: 性能评价】")

print("\n【训练集性能】")

train_accuracy = accuracy_score(y_train, y_train_pred)

train_precision = precision_score(y_train, y_train_pred, average='weighted')

train_recall = recall_score(y_train, y_train_pred, average='weighted')

train_f1 = f1_score(y_train, y_train_pred, average='weighted')

print(f"准确率 (Accuracy): {train_accuracy:.4f}")

print(f"精确率 (Precision): {train_precision:.4f}")

print(f"召回率 (Recall): {train_recall:.4f}")

print(f"F1值 (F1-Score): {train_f1:.4f}")

print("\n【测试集性能】")

test_accuracy = accuracy_score(y_test, y_test_pred)

test_precision = precision_score(y_test, y_test_pred, average='weighted')

test_recall = recall_score(y_test, y_test_pred, average='weighted')

test_f1 = f1_score(y_test, y_test_pred, average='weighted')

print(f"准确率 (Accuracy): {test_accuracy:.4f}")

print(f"精确率 (Precision): {test_precision:.4f}")

print(f"召回率 (Recall): {test_recall:.4f}")

print(f"F1值 (F1-Score): {test_f1:.4f}")

# 详细分类报告

print("\n【详细分类报告】")

print(classification_report(y_test, y_test_pred, target_names=label_encoder.classes_, digits=4))

# 7. 特征重要性分析

print("\n【步骤7: 特征重要性分析】")

feature_names = []

feature_names.extend([f'tactic_{i}' for i in range(100)])

feature_names.extend([f'technique_{i}' for i in range(100)])

feature_names.extend([f'tid_{i}' for i in range(50)])

feature_names.extend([f'api_{i}' for i in range(200)])

feature_names.extend([f'dynamic_api_{i}' for i in range(200)])

feature_importance = rf_model.feature_importances_

top_indices = np.argsort(feature_importance)[-20:][::-1]

print("Top 20 重要特征:")

for idx in top_indices:

print(f"  {feature_names[idx]}: {feature_importance[idx]:.6f}")

# 8. 可视化

print("\n【步骤8: 绘制可视化图表】")

# 创建可视化保存目录

pic_dir = 'c:/Users/xiuzhang/Desktop/mal_analysis/pic/random_forest'

os.makedirs(pic_dir, exist_ok=True)

# 8.1 混淆矩阵

cm_train = confusion_matrix(y_train, y_train_pred)

cm_test = confusion_matrix(y_test, y_test_pred)

fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# 训练集混淆矩阵

sns.heatmap(cm_train, annot=True, fmt='d', cmap='Blues',

xticklabels=label_encoder.classes_,

yticklabels=label_encoder.classes_,

ax=axes[0])

axes[0].set_xlabel('预测标签', fontsize=12)

axes[0].set_ylabel('真实标签', fontsize=12)

axes[0].set_title(f'训练集混淆矩阵\n准确率: {train_accuracy:.4f}', fontsize=14, fontweight='bold')

# 测试集混淆矩阵

sns.heatmap(cm_test, annot=True, fmt='d', cmap='Greens',

xticklabels=label_encoder.classes_,

yticklabels=label_encoder.classes_,

ax=axes[1])

axes[1].set_xlabel('预测标签', fontsize=12)

axes[1].set_ylabel('真实标签', fontsize=12)

axes[1].set_title(f'测试集混淆矩阵\n准确率: {test_accuracy:.4f}', fontsize=14, fontweight='bold')

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '混淆矩阵.png'), dpi=300, bbox_inches='tight')

print(f"混淆矩阵已保存至: {os.path.join(pic_dir, '混淆矩阵.png')}")

# 8.2 性能指标对比

metrics = ['准确率', '精确率', '召回率', 'F1值']

train_scores = [train_accuracy, train_precision, train_recall, train_f1]

test_scores = [test_accuracy, test_precision, test_recall, test_f1]

fig, ax = plt.subplots(figsize=(10, 6))

x = np.arange(len(metrics))

width = 0.35

bars1 = ax.bar(x - width/2, train_scores, width, label='训练集', color='steelblue', alpha=0.8)

bars2 = ax.bar(x + width/2, test_scores, width, label='测试集', color='lightcoral', alpha=0.8)

ax.set_xlabel('性能指标', fontsize=12)

ax.set_ylabel('分数', fontsize=12)

ax.set_title('随机森林模型性能对比', fontsize=14, fontweight='bold')

ax.set_xticks(x)

ax.set_xticklabels(metrics)

ax.legend(fontsize=11)

ax.set_ylim([0, 1.1])

ax.grid(axis='y', alpha=0.3)

# 添加数值标签

for bars in [bars1, bars2]:

for bar in bars:

height = bar.get_height()

ax.text(bar.get_x() + bar.get_width()/2., height,

f'{height:.4f}',

ha='center', va='bottom', fontsize=10, fontweight='bold')

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '性能指标对比.png'), dpi=300, bbox_inches='tight')

print(f"性能指标对比图已保存至: {os.path.join(pic_dir, '性能指标对比.png')}")

# 8.3 每个类别的性能指标

precision_per_class = precision_score(y_test, y_test_pred, average=None)

recall_per_class = recall_score(y_test, y_test_pred, average=None)

f1_per_class = f1_score(y_test, y_test_pred, average=None)

fig, ax = plt.subplots(figsize=(12, 6))

x = np.arange(len(label_encoder.classes_))

width = 0.25

bars1 = ax.bar(x - width, precision_per_class, width, label='精确率', color='skyblue', alpha=0.8)

bars2 = ax.bar(x, recall_per_class, width, label='召回率', color='lightgreen', alpha=0.8)

bars3 = ax.bar(x + width, f1_per_class, width, label='F1值', color='salmon', alpha=0.8)

ax.set_xlabel('恶意家族类别', fontsize=12)

ax.set_ylabel('分数', fontsize=12)

ax.set_title('各恶意家族类别性能指标', fontsize=14, fontweight='bold')

ax.set_xticks(x)

ax.set_xticklabels(label_encoder.classes_)

ax.legend(fontsize=11)

ax.set_ylim([0, 1.1])

ax.grid(axis='y', alpha=0.3)

# 添加数值标签

for bars in [bars1, bars2, bars3]:

for bar in bars:

height = bar.get_height()

ax.text(bar.get_x() + bar.get_width()/2., height,

f'{height:.4f}',

ha='center', va='bottom', fontsize=9)

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '各类别性能指标.png'), dpi=300, bbox_inches='tight')

print(f"各类别性能指标图已保存至: {os.path.join(pic_dir, '各类别性能指标.png')}")

# 8.4 特征重要性Top 20

fig, ax = plt.subplots(figsize=(12, 8))

top_feature_names = [feature_names[i] for i in top_indices]

top_feature_importance = feature_importance[top_indices]

colors = plt.cm.viridis(np.linspace(0.3, 0.9, len(top_indices)))

bars = ax.barh(range(len(top_indices)), top_feature_importance, color=colors)

ax.set_yticks(range(len(top_indices)))

ax.set_yticklabels(top_feature_names, fontsize=9)

ax.set_xlabel('特征重要性', fontsize=12)

ax.set_ylabel('特征名称', fontsize=12)

ax.set_title('随机森林模型 - Top 20 重要特征', fontsize=14, fontweight='bold')

ax.invert_yaxis()

# 添加数值标签

for i, bar in enumerate(bars):

width = bar.get_width()

ax.text(width, bar.get_y() + bar.get_height()/2.,

f'{width:.4f}',

ha='left', va='center', fontsize=8, fontweight='bold')

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '特征重要性.png'), dpi=300, bbox_inches='tight')

print(f"特征重要性图已保存至: {os.path.join(pic_dir, '特征重要性.png')}")

# 8.5 归一化混淆矩阵(百分比)

cm_test_normalized = cm_test.astype('float') / cm_test.sum(axis=1)[:, np.newaxis]

fig, ax = plt.subplots(figsize=(10, 8))

sns.heatmap(cm_test_normalized, annot=True, fmt='.2%', cmap='YlGnBu',

xticklabels=label_encoder.classes_,

yticklabels=label_encoder.classes_,

cbar_kws={'label': '比例'})

ax.set_xlabel('预测标签', fontsize=12)

ax.set_ylabel('真实标签', fontsize=12)

ax.set_title('测试集归一化混淆矩阵(百分比)', fontsize=14, fontweight='bold')

plt.tight_layout()

plt.savefig(os.path.join(pic_dir, '归一化混淆矩阵.png'), dpi=300, bbox_inches='tight')

print(f"归一化混淆矩阵已保存至: {os.path.join(pic_dir, '归一化混淆矩阵.png')}")

# 8.6 模型性能汇总表

fig, ax = plt.subplots(figsize=(12, 6))

ax.axis('tight')

ax.axis('off')

table_data = []

table_data.append(['数据集', '准确率', '精确率', '召回率', 'F1值'])

table_data.append(['训练集', f'{train_accuracy:.4f}', f'{train_precision:.4f}',

f'{train_recall:.4f}', f'{train_f1:.4f}'])

table_data.append(['测试集', f'{test_accuracy:.4f}', f'{test_precision:.4f}',

f'{test_recall:.4f}', f'{test_f1:.4f}'])

table = ax.table(cellText=table_data, cellLoc='center', loc='center')

table.auto_set_font_size(False)

table.set_fontsize(12)

table.scale(1.2, 1.5)

# 设置表头样式

for i in range(len(table_data[0])):

table[(0, i)].set_facecolor('#4472C4')

table[(0, i)].set_text_props(weight='bold', color='white')

plt.title('随机森林模型性能汇总', fontsize=16, fontweight='bold', pad=20)

plt.savefig(os.path.join(pic_dir, '模型性能汇总.png'), dpi=300, bbox_inches='tight')

print(f"模型性能汇总表已保存至: {os.path.join(pic_dir, '模型性能汇总.png')}")

print("\n" + "=" * 80)

print("模型训练和评价完成!")

print("=" * 80)

print(f"\n所有可视化图表保存在: {pic_dir}")

print("\n生成图表列表:")

print("  - 混淆矩阵.png")

print("  - 性能指标对比.png")

print("  - 各类别性能指标.png")

print("  - 特征重要性.png")

print("  - 归一化混淆矩阵.png")

print("  - 模型性能汇总.png")

print("\n" + "=" * 80)

print("最终性能评价总结")

print("=" * 80)

print(f"\n【测试集性能】")

print(f"  准确率 (Accuracy):   {test_accuracy:.4f}")

print(f"  精确率 (Precision):  {test_precision:.4f}")

print(f"  召回率 (Recall):     {test_recall:.4f}")

print(f"  F1值 (F1-Score):     {test_f1:.4f}")

print(f"\n【模型结论】")

if test_accuracy > 0.9:

print("  模型表现优秀!准确率超过90%")

elif test_accuracy > 0.8:

print("  模型表现良好!准确率超过80%")

elif test_accuracy > 0.7:

print("  模型表现中等,准确率超过70%")

else:

print("  模型需要进一步优化")

# 1. 定义自定义数据集类

class MalwareDataset(Dataset):

def __init__(self, features, labels):

self.features = torch.FloatTensor(features)

self.labels = torch.LongTensor(labels)

def __len__(self):

return len(self.labels)

def __getitem__(self, idx):

return self.features[idx], self.labels[idx]

# 2. 定义CNN-BiLSTM模型

class CNNBiLSTM(nn.Module):

def __init__(self, input_dim, hidden_dim, num_layers, num_classes, dropout=0.5):

super(CNNBiLSTM, self).__init__()

# CNN部分

self.conv1 = nn.Conv1d(in_channels=1, out_channels=64, kernel_size=3, padding=1)

self.conv2 = nn.Conv1d(in_channels=64, out_channels=128, kernel_size=3, padding=1)

self.pool = nn.MaxPool1d(kernel_size=2)

self.dropout1 = nn.Dropout(dropout)

# 计算CNN输出维度

# 输入: (batch_size, 1, input_dim)

# Conv1: (batch_size, 64, input_dim)

# Pool1: (batch_size, 64, input_dim//2)

# Conv2: (batch_size, 128, input_dim//2)

# Pool2: (batch_size, 128, input_dim//4)

self.cnn_output_dim = 128 * (input_dim // 4)

# BiLSTM部分

self.bilstm = nn.LSTM(

input_size=self.cnn_output_dim,

hidden_size=hidden_dim,

num_layers=num_layers,

batch_first=True,

bidirectional=True,

dropout=dropout if num_layers > 1 else 0

)

# 全连接层

self.dropout2 = nn.Dropout(dropout)

self.fc = nn.Linear(hidden_dim * 2, num_classes)  # 双向LSTM输出是2倍hidden_dim

# 激活函数

self.relu = nn.ReLU()

def forward(self, x):

# x shape: (batch_size, input_dim)

# Reshape for CNN: (batch_size, 1, input_dim)

x = x.unsqueeze(1)

# CNN部分

x = self.conv1(x)  # (batch_size, 64, input_dim)

x = self.relu(x)

x = self.pool(x)  # (batch_size, 64, input_dim//2)

x = self.dropout1(x)

x = self.conv2(x)  # (batch_size, 128, input_dim//2)

x = self.relu(x)

x = self.pool(x)  # (batch_size, 128, input_dim//4)

x = self.dropout1(x)

# Flatten for LSTM: (batch_size, cnn_output_dim)

x = x.view(x.size(0), -1)

# Reshape for LSTM: (batch_size, 1, cnn_output_dim)

x = x.unsqueeze(1)

# BiLSTM部分

lstm_out, (h_n, c_n) = self.bilstm(x)  # h_n shape: (num_layers*2, batch_size, hidden_dim)

# 使用最后一个时间步的输出

# 拼接前向和后向的最终隐藏状态

h_forward = h_n[-2]  # 前向最后一层

h_backward = h_n[-1]  # 后向最后一层

x = torch.cat([h_forward, h_backward], dim=1)  # (batch_size, hidden_dim*2)

# 全连接层

x = self.dropout2(x)

x = self.fc(x)  # (batch_size, num_classes)

return x

# 3. 读取数据

print("\n【步骤1: 读取数据】")

train_df = pd.read_csv('c:/Users/xiuzhang/Desktop/mal_analysis/processed/train_dataset.csv')

test_df = pd.read_csv('c:/Users/xiuzhang/Desktop/mal_analysis/processed/test_dataset.csv')

print(f"训练集样本数: {len(train_df)}")

print(f"测试集样本数: {len(test_df)}")

# 4. 特征工程

print("\n【步骤2: 特征工程】")

feature_columns = ['tactic', 'technique', 'tid', 'api', 'dynamic_api']

# 填充缺失值

for col in feature_columns:

train_df[col] = train_df[col].fillna('')

test_df[col] = test_df[col].fillna('')

# 使用TF-IDF编码

print("使用TF-IDF对文本特征进行编码...")

tactic_tfidf = TfidfVectorizer(max_features=100, token_pattern=r'(?u)\b\w+\b|;')

technique_tfidf = TfidfVectorizer(max_features=100, token_pattern=r'(?u)\b\w+\b|;')

tid_tfidf = TfidfVectorizer(max_features=50, token_pattern=r'(?u)\b\w+\b|;')

api_tfidf = TfidfVectorizer(max_features=200, token_pattern=r'(?u)\b\w+\b|;')

dynamic_api_tfidf = TfidfVectorizer(max_features=200, token_pattern=r'(?u)\b\w+\b|;')

# 训练集

train_tactic = tactic_tfidf.fit_transform(train_df['tactic'].astype(str)).toarray()

train_technique = technique_tfidf.fit_transform(train_df['technique'].astype(str)).toarray()

train_tid = tid_tfidf.fit_transform(train_df['tid'].astype(str)).toarray()

train_api = api_tfidf.fit_transform(train_df['api'].astype(str)).toarray()

train_dynamic_api = dynamic_api_tfidf.fit_transform(train_df['dynamic_api'].astype(str)).toarray()

X_train = np.hstack([train_tactic, train_technique, train_tid, train_api, train_dynamic_api])

# 测试集

test_tactic = tactic_tfidf.transform(test_df['tactic'].astype(str)).toarray()

test_technique = technique_tfidf.transform(test_df['technique'].astype(str)).toarray()

test_tid = tid_tfidf.transform(test_df['tid'].astype(str)).toarray()

test_api = api_tfidf.transform(test_df['api'].astype(str)).toarray()

test_dynamic_api = dynamic_api_tfidf.transform(test_df['dynamic_api'].astype(str)).toarray()

X_test = np.hstack([test_tactic, test_technique, test_tid, test_api, test_dynamic_api])

print(f"训练集特征向量维度: {X_train.shape}")

print(f"测试集特征向量维度: {X_test.shape}")

# 5. 标签编码

print("\n【步骤3: 标签编码】")

label_encoder = LabelEncoder()

y_train = label_encoder.fit_transform(train_df['label'])

y_test = label_encoder.transform(test_df['label'])

print(f"标签类别: {label_encoder.classes_}")

print(f"标签数量: {len(label_encoder.classes_)}")

# 6. 创建数据加载器

print("\n【步骤4: 创建数据加载器】")

train_dataset = MalwareDataset(X_train, y_train)

test_dataset = MalwareDataset(X_test, y_test)

batch_size = 32

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

print(f"训练集批次数: {len(train_loader)}")

print(f"测试集批次数: {len(test_loader)}")

# 7. 创建模型

print("\n【步骤5: 创建CNN-BiLSTM模型】")

input_dim = X_train.shape[1]  # 560

hidden_dim = 128

num_layers = 2

num_classes = len(label_encoder.classes_)  # 5

model = CNNBiLSTM(input_dim, hidden_dim, num_layers, num_classes, dropout=0.5)

model = model.to(device)

print(f"模型结构:")

print(model)

print(f"\n模型参数数量: {sum(p.numel() for p in model.parameters()):,}")

# 8. 定义损失函数和优化器

criterion = nn.CrossEntropyLoss()

optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=5, verbose=True)

▼点击下方,即可购书

原文链接:https://mp.weixin.qq.com/s?__biz=Mzg5MTM5ODU2Mg==&mid=2247502946&idx=1&sn=38d1088b04e7a97a9c3dd99134d1bcc5