原创 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)
▼点击下方,即可购书