第一步，打开CodeBuddy。 随后，选择桌面的文件夹，整个分析过程生成的代码和执行结果将在该文件夹中实现。

第二步，在右下角对话框中选择大模型，并输入详细的数据预处理提示词。 注意，除CodeBuddy自带大模型外，读者可以自己搭建模型，各类模型均可使用。此外，动态特征与静态特征融合时需要按照相同md5值进行融合与交叉验证，该部分前面已完成，故不涉及。

该项目中具有data文件夹，存储5个恶意家族的特征序列，现在需要撰写Python代码对数据集进行预处理和划分。代码的具体要求如下： %20%20（1）整个数据集包含8个特征，分别是%20[no,%20label,%20md5,%20tactic,%20technique,%20tid,%20api,%20dynamic_api]，现在需要撰写代码对五个CSV文件数据集进行融合。 %20%20（2）按照6:3:1的比例将整合后的数据集文件，随机划分成三个CSV文件，分别对应训练集、测试集和验证集。 %20%20（3）撰写代码统计分析处理后的数据集分布情况，并绘制相关的可视化图。 %20%20注意，CSV文件样本数量在合并前后一定要一致，数据集要随机划分。

第三步，输入提示词并运行程序。CodeBuddy会调用大模型深度思考，从而完成相关任务。

下图展示了其修改代码的过程，其自动生成了data_preprocessing.py文件，并将处理的文件保存至processed文件夹中。

注意，CodeBuddy会自动生成代码、调试代码、运行代码和优化代码，真的是一个非常棒的AI%20Coding工具。生成代码点击“Keep”按钮即表示接受，通常在所有程序执行完毕且效果符合需求后点击。

该工程目录如下：

第四步，程序自动运行并在线显示可视化分析结果。 如下图所示，详细展示了5个恶意家族的数据分布情况。注意，大家在真实的科研中，需要对其进行验证，确保数据真实可靠。

最终划分的数据集包含图和表，最终预处理的代码如下所示：

AI%20Coding生成的代码更多是辅助大家完成具体的功能，当然大家也可以学习AI生成代码的规范和逻辑，从而更好地帮助我们理解恶意代码智能分析。

import pandas as pdimport numpy as npimport osimport matplotlib.pyplot as pltimport seaborn as snsfrom sklearn.model_selection import train_test_split
#%20设置中文字体plt.rcParams['font.sans-serif']%20=%20['SimHei']plt.rcParams['axes.unicode_minus']%20= False
#%20读取数据文件夹中的所有CSV文件data_dir%20= 'c:/Users/xiuzhang/Desktop/mal_analysis/data'csv_files%20=%20[os.path.join(data_dir,%20f) for f in os.listdir(data_dir) if f.endswith('.csv') and 'result_final' in f]
print("=" * 80)print("步骤1:%20读取并合并所有CSV文件")print("=" * 80)
#%20读取所有CSV文件dfs%20=%20[]sample_counts%20=%20{}total_before_clean%20= 0total_after_clean%20= 0
for csv_file in csv_files: %20 %20file_name%20=%20os.path.basename(csv_file) %20 %20df%20=%20pd.read_csv(csv_file)
 %20  #%20清理数据：删除label为NaN的行 %20 %20before_clean%20= len(df) %20 %20df_cleaned%20=%20df.dropna(subset=['label']) %20 %20after_clean%20= len(df_cleaned)
 %20 %20sample_counts[file_name]%20= len(df_cleaned) %20 %20dfs.append(df_cleaned) %20 %20total_before_clean%20+=%20before_clean %20 %20total_after_clean%20+=%20after_clean
 %20  print(f"读取文件: {file_name}") %20  print(f"%20 原始样本数量: {before_clean}") %20  print(f"%20 清理后样本数量: {after_clean}") %20  print(f"%20 删除的NaN行数: {before_clean%20-%20after_clean}")
#%20合并所有数据集merged_df%20=%20pd.concat(dfs,%20ignore_index=True)print(f"\n合并后总样本数量: {len(merged_df)}")print(f"合并前各文件样本数量之和: {sum(sample_counts.values())}")print(f"合并前后样本数量是否一致: {len(merged_df)%20== sum(sample_counts.values())}")print(f"\n【数据清理统计】")print(f"清理前总样本数: {total_before_clean}")print(f"清理后总样本数: {total_after_clean}")print(f"删除的无效行数: {total_before_clean%20-%20total_after_clean}")print(f"保留率: {total_after_clean/total_before_clean*100:.2f}%")
#%20移除样本数量过少的类别（样本数量小于10的类别）label_counts%20=%20merged_df['label'].value_counts()valid_labels%20=%20label_counts[label_counts%20>= 10].indexmerged_df%20=%20merged_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)%20- len(valid_labels)}")print(f"过滤后样本数量: {len(merged_df)}")
#%20保存合并后的数据集output_dir%20= 'c:/Users/xiuzhang/Desktop/mal_analysis/processed'os.makedirs(output_dir,%20exist_ok=True)merged_df.to_csv(os.path.join(output_dir, 'merged_dataset.csv'),%20index=False)print(f"\n合并后的数据集已保存至: {os.path.join(output_dir, 'merged_dataset.csv')}")
print("\n" + "=" * 80)print("步骤2:%20按照6:3:1比例划分数据集")print("=" * 80)
#%20首先打乱数据merged_df_shuffled%20=%20merged_df.sample(frac=1,%20random_state=42).reset_index(drop=True)
#%20按照6:3:1的比例划分#%206:3:1%20=%2060%:30%:10%train_ratio%20= 0.6val_ratio%20= 0.3test_ratio%20= 0.1
#%20第一次划分:%20训练集%20+%20临时集train_df,%20temp_df%20=%20train_test_split( %20 %20merged_df_shuffled, %20 %20test_size=(val_ratio%20+%20test_ratio), %20 %20random_state=42, %20 %20stratify=merged_df_shuffled['label'])
#%20第二次划分:%20从临时集中划分验证集和测试集val_df,%20test_df%20=%20train_test_split( %20 %20temp_df, %20 %20test_size=(test_ratio%20/%20(val_ratio%20+%20test_ratio)),%20 #%200.1%20/%20(0.3%20+%200.1)%20=%200.25 %20 %20random_state=42, %20 %20stratify=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)%20+ len(val_df)%20+ len(test_df)}")print(f"划分前后样本数量是否一致: {len(merged_df)%20== len(train_df)%20+ len(val_df)%20+ len(test_df)}")
#%20保存划分后的数据集train_df.to_csv(os.path.join(output_dir, 'train_dataset.csv'),%20index=False)val_df.to_csv(os.path.join(output_dir, 'val_dataset.csv'),%20index=False)test_df.to_csv(os.path.join(output_dir, 'test_dataset.csv'),%20index=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:%20统计分析数据集分布情况")print("=" * 80)
#%203.1%20标签分布统计print("\n【合并数据集标签分布】")label_distribution%20=%20merged_df['label'].value_counts().sort_index()print(label_distribution)print(f"\n标签数量: {len(label_distribution)}")print(f"样本总数: {len(merged_df)}")
#%203.2%20各数据集的标签分布print("\n【训练集标签分布】")train_label_dist%20=%20train_df['label'].value_counts().sort_index()print(train_label_dist)
print("\n【验证集标签分布】")val_label_dist%20=%20val_df['label'].value_counts().sort_index()print(val_label_dist)
print("\n【测试集标签分布】")test_label_dist%20=%20test_df['label'].value_counts().sort_index()print(test_label_dist)
#%203.3%20原始文件统计print("\n【原始CSV文件样本统计】")print(f"文件名{'%20'*20}样本数量")print("-" * 40)for file_name,%20count in sorted(sample_counts.items()): %20  print(f"{file_name:30s}{count:>10}")
print("\n" + "=" * 80)print("步骤4:%20绘制可视化图表")print("=" * 80)
#%20创建可视化图表保存目录pic_dir%20= 'c:/Users/xiuzhang/Desktop/mal_analysis/pic/analysis'os.makedirs(pic_dir,%20exist_ok=True)
#%204.1%20原始文件样本数量分布plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)sorted_files%20= sorted(sample_counts.items(),%20key=lambda x:%20x[0])file_names%20=%20[item[0] for item in sorted_files]file_counts%20=%20[item[1] for item in sorted_files]colors%20=%20plt.cm.Set3(range(len(file_names)))bars%20=%20plt.bar(file_names,%20file_counts,%20color=colors)plt.xlabel('恶意家族文件',%20fontsize=12)plt.ylabel('样本数量',%20fontsize=12)plt.title('各恶意家族样本数量分布',%20fontsize=14,%20fontweight='bold')plt.xticks(rotation=45,%20ha='right')#%20添加数值标签for bar in bars: %20 %20height%20=%20bar.get_height() %20 %20plt.text(bar.get_x()%20+%20bar.get_width()/2.,%20height, %20 %20 %20 %20 %20 %20 f'{int(height)}', %20 %20 %20 %20 %20 %20 ha='center',%20va='bottom',%20fontsize=9)plt.grid(axis='y',%20alpha=0.3)
#%204.2%20合并数据集标签分布plt.subplot(1, 2, 2)label_names%20=%20label_distribution.index.tolist()label_counts%20=%20label_distribution.values.tolist()colors%20=%20plt.cm.Set2(range(len(label_names)))bars%20=%20plt.bar(label_names,%20label_counts,%20color=colors)plt.xlabel('标签类别',%20fontsize=12)plt.ylabel('样本数量',%20fontsize=12)plt.title('合并数据集标签分布',%20fontsize=14,%20fontweight='bold')#%20添加数值标签for bar in bars: %20 %20height%20=%20bar.get_height() %20 %20plt.text(bar.get_x()%20+%20bar.get_width()/2.,%20height, %20 %20 %20 %20 %20 %20 f'{int(height)}', %20 %20 %20 %20 %20 %20 ha='center',%20va='bottom',%20fontsize=10)plt.grid(axis='y',%20alpha=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")

您是否感受到了大模型和AI Coding的魅力和力量！

3.AI赋能基于机器学习的恶意家族分类

随后，我们将基于预处理的数据集开展基于机器学习的恶意代码分析。

第一步，构建精准的提示词。

请撰写python代码构建随机森林模型，读取processed中的训练集train_dataset.csv和测试集test_dataset.csv的数据，利用[tactic,technique,tid,api,dynamic_api]五维特征用来构建向量，五列特征融合了恶意代码的静态和动态特征，直接拼接成数据集，其分类家族为[label]列，总共5个家族。请利用sklearn构建随机森林算法评价性能，要求保留4位有效数字，包括精确率、召回率、F1值和准确率。请给出详细代码，并绘制可视化图形（包括混淆矩阵图）。

第二步，将提示词输入对话框中，选择大模型并进行提交。

4.AI赋能基于深度学习的恶意家族分类

接下来，我们利用CodeBuddy生成深度学习CNN-BiLSTM模型实现家族分类。

第一步，构建提示词。

请撰写python Pytorch代码构建CNN-BiLSTM模型，读取processed中的训练集train_dataset.csv和测试集test_dataset.csv的数据，利用[tactic,technique,tid,api,dynamic_api]五维特征用来构建向量，五列特征融合了恶意代码的静态和动态特征，直接拼接成数据集，其分类家族为[label]列，总共5个家族。请利用CNN-BiLSTM模型进行恶意家族分类并评价性能，要求保留4位有效数字，包括精确率、召回率、F1值和准确率。请给出详细代码，并绘制可视化图形（包括混淆矩阵图），保证程序能顺利运行。

第二步，在CodeBuddy中输入提示词，经过深度思考后生成代码。

第三步，自动运行生成的深度学习代码。

由于作者是用CPU，因此代码运行比较耗时，因此该代码请大家自行尝试。注意，如果代码运行报错，大家一定要学会与CodeBuddy对话，从而优化代码直至完成相关功能。

最终生成代码如下图所示，整个代码量500多行还是非常大的。

模型构建部分的关键代码如下，完整代码请参考作者的Github。

• https://github.com/eastmountyxz/LLM-for-Malware

# 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 = 32train_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]  # 560hidden_dim = 128num_layers = 2num_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)

5.AI赋能可视化聚类分析

最后，我们尝试进行可视化降维分析，提示词如下：

现在需要进行降维可视化分析，请读取test_dataset.csv文件中的特征[tactic,technique,tid,api,dynamic_api]来构建向量，利用t-SNE进行可视化分析，其分类的家族为label列，共5个家族。最终呈现美观的聚类效果图。注意，整个代码利用Python实现，并且家族之间颜色不同，呈现的效果美观。

运行结果如下图所示，还需要进一步结合实验特征优化表征。

四.总结

本文围绕 AI Coding 与安全分析的融合实践，系统探讨了 CodeBuddy 在恶意代码分析与家族分类中的应用路径。从传统静态与动态特征分析的局限性出发，文章展示了大语言模型驱动的 AI Coding 如何在特征提取、数据预处理、分类建模与可视化分析等环节中显著提升分析效率与工程一致性，体现了智能化方法在复杂安全任务中的现实价值。

未来，大语言模型（LLM）与智能体（Agent）将在恶意代码分析领域扮演更加核心的角色。

• 在特征建模层面，LLM 有望实现对二进制代码、反汇编结果和运行日志的语义级理解，从而减少对人工特征工程的依赖，提升对混淆、变种与对抗样本的鲁棒性。
• 在分析流程层面，引入具备规划与执行能力的安全智能体，可将恶意代码分析任务拆解为自动化的多步骤流程，实现从样本采集、行为分析到家族归因的自主协同分析。
• 在知识层面，LLM 可与知识图谱和威胁情报库深度融合，支持跨样本、跨家族的关联推理与攻击链重构，增强分析结果的可解释性与可追溯性。

此外，在工程实践中，AI Coding 平台与安全工具链的深度集成，将推动恶意代码分析从“工具驱动”向“智能协作”转变，使安全分析人员逐步从底层实现细节中解放出来，更多关注威胁建模与决策支持问题。总体而言，LLM 与智能体的引入不仅将重塑恶意代码分析的技术路径，也为构建高效、智能、可演化的安全分析体系提供了重要发展方向。

与此同时，Eastmount已正式开启《智能体攻防实战》专栏，将持续发布关于大模型辅助编程、国产AI IDE工具评测、AI自动化开发实战等系列内容，欢迎关注专栏，一起探索智能开发的前沿趋势，不断学习与精进。基础性文章，希望对您有所帮助，写得不好的地方还请海涵！

『网络攻防和AI安全之家』目前收到了很多博友、朋友和老师的支持和点赞，并且保持每周七次更新，尤其是一些看了我文章多年的老粉，购买来感谢，真的很感动，类目。未来，我将分享更多高质量文章，更多安全干货，真心帮助到大家。虽然起步晚，但贵在坚持，像十多年如一日的博客分享那样，脚踏实地，只争朝夕。继续加油，再次感谢！尤其是一些看了我文章多年的老粉，购买来感谢，真的很感动，类目。未来，我将分享更多高质量文章，更多安全干货，真心帮助到大家。虽然起步晚，但贵在坚持，像十多年如一日的博客分享那样，脚踏实地，只争朝夕。继续加油，再次感谢！

(By:Eastmount 2026-06-16 周二写于贵阳 )

团队新书推荐 腾讯内部10倍产能提升的秘密是什么？AI编程如何真正落地到日常开发，让每位开发者都能享受效率红利？腾讯云CODING CEO刘毅等多位业内大咖给出了明确答案：选对工具，掌握方法。他们推荐的《CodeBuddy领航：AI辅助编程应用·架构·交付》，正是承载这套方法的最佳实践指南。

京东和当当搜索购买本书，欢迎大家交流！

▼点击下方，即可购书

本书立足国内开发者真实场景，以解决落地痛点为核心，不仅系统讲解AI编程的核心理念与方法，更依托深度集成大语言模型的本土化平台CodeBuddy，通过数十个完整实战项目，演示如何将AI能力应用于需求分析、界面设计、代码生成、测试部署等全链路开发流程。

书中最具亮点的是一套完整落地的实战内容：12个章节搭配数十个实战项目，将CodeBuddy的使用技巧与真实开发场景深度融合，覆盖当前主流热门开发方向，让读者学有所用、学完即可用。

与其在焦虑中观望，不如主动拥抱变革。《CodeBuddy领航：AI辅助编程应用·架构·交付》就是你开启AI编程之路的最佳伙伴——它不仅能帮你快速掌握CodeBuddy的使用方法，更能帮你建立“人机协同”的思维，在这场效率革命中提升自身价值，值得一读！

免责声明：

本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。

任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。

本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。

本文转载自：娜璋AI安全之家 Eastmount Eastmount《[智能体攻防实战] 二.CodeBuddy赋能恶意代码分析与家族分类实践》