为了更好地分享AI Agent在网络安全领域的实践方法与应用经验，作者正式开启“智能体攻防实战”专栏。本专栏将围绕“大模型如何赋能网络安全攻防实践”和“大模型及智能体内生安全”这两个主题展开，重点关注AI Agent、AI Coding、自动化分析、入侵检测、威胁情报、漏洞研判与安全运营等方向，尝试将大模型的语义理解、代码生成、工具调用和安全知识推理能力融入真实安全任务中。通过系列化案例，专栏希望降低网络安全实验、算法复现和工具开发的实践门槛，为安全研究人员、开发者和初学者提供更加直观、可操作的技术参考。基础文章，希望对您有帮助。感恩分享的第15年，fighting！

本文作为“智能体攻防实战”专栏的第一篇，将以“大模型赋能网络入侵检测”为核心任务，探索如何借助CodeBuddy和d.run完成入侵检测实验的构建与运行。文章首先概述AI Agent在网络安全中的典型应用，然后基于CodeBuddy自动生成机器学习与深度学习入侵检测代码，进一步结合d.run在线环境完成实验运行、模型评估和结果分析。通过该案例，读者可以初步理解AI Agent如何贯穿数据预处理、特征提取、模型训练、性能评估和报告生成等环节，为后续开展智能化安全分析与攻防实验奠定基础。

代码开源地址：

• https://github.com/eastmountyxz/Agent-for-security

前文赏析：

• [智能体攻防实战] 一.大模型赋能网络入侵检测实战探索（CodeBuddy和d.run实现）

传统安全专栏：

---

一.AI Agent赋能网络安全概述

随着大模型、AI Coding与自动化生成技术的发展，AI Agent正在成为网络安全领域的重要智能化支撑。与传统安全工具主要依赖规则库、特征库和人工配置不同，AI Agent能够基于自然语言理解、安全知识推理和多源数据分析能力，对网络流量、系统日志、威胁情报、漏洞信息和告警事件进行综合研判。其核心作用并不是简单替代安全人员，而是将大模型的理解能力与安全工具链的执行能力结合起来，辅助完成从威胁发现、异常分析、攻击溯源到响应处置的全过程任务，从而提升网络安全工作的自动化、智能化和可解释化水平。

在实际应用中，AI Agent更适合作为网络安全任务中的“智能协同助手”。一方面，它可以帮助安全人员快速理解复杂数据和异常现象，例如对入侵检测结果进行解释、对日志告警进行归因、对漏洞风险进行分析；另一方面，它也可以调用代码运行、数据分析、可视化展示和报告生成等工具，辅助完成安全实验与工程实践。尤其在网络入侵检测场景中，AI Agent能够贯穿数据预处理、特征提取、模型构建、性能评估和结果分析等环节。

AI Agent赋能网络安全的本质，是将大模型的语义理解、知识推理、代码生成与工具调用能力嵌入安全业务流程，使其能够辅助完成“感知—分析—决策—响应”的闭环任务。具体而言，其应用可体现在以下几个方面。

• 网络入侵检测辅助
  AI Agent可参与网络流量数据分析、异常行为识别与入侵检测模型构建，辅助安全人员发现潜在攻击行为。相较于传统规则检测方法，Agent能够结合上下文语义、历史告警和模型输出结果，对异常流量进行更具解释性的分析。

• 安全日志智能分析
  在主机日志、系统日志、防火墙日志和Web访问日志分析中，AI Agent能够自动提取关键字段、识别异常模式并归纳事件线索。其优势在于能够将分散的日志信息转化为结构化安全事件，降低人工筛查成本。

• 威胁情报理解与关联
  AI Agent可以对安全报告、漏洞公告、APT分析文章和开源威胁情报进行语义解析，提取攻击组织、攻击工具、漏洞编号、攻击手法等关键信息。通过与ATT&CK框架、历史事件和内部告警进行关联，Agent能够辅助判断威胁来源与攻击阶段。

• 漏洞分析与风险研判
  面对漏洞描述、CVE公告和代码片段，AI Agent可辅助分析漏洞成因、影响范围和潜在利用方式。它还可以结合资产信息与暴露面情况，对漏洞风险进行优先级排序，帮助安全团队确定修复顺序。

• 恶意代码辅助分析
  在恶意脚本、可疑样本或混淆代码分析中，AI Agent能够辅助解释代码逻辑、识别可疑函数调用和潜在恶意行为。对于安全初学者或分析人员而言，Agent可将复杂代码行为转化为可理解的自然语言说明。

• 攻击链溯源分析
  AI Agent能够将告警、日志、流量和威胁情报进行关联，辅助还原攻击者从初始访问到横向移动、权限提升和数据外传的完整路径。通过攻击链视角分析，安全人员可以更清晰地理解攻击过程和关键风险节点。

• 检测规则生成与优化
  AI Agent可根据攻击样本、日志特征或威胁情报内容，辅助生成YARA规则、Sigma规则、Snort规则或IDS检测逻辑。与此同时，它还可以根据误报情况和样本变化，对规则条件进行优化，提高检测规则的适用性。

• 安全自动化响应
  在安全运营场景中，AI Agent可根据告警等级和处置策略，辅助生成封禁IP、隔离主机、停用账号或通知管理员等响应建议。与自动化工具结合后，Agent能够推动部分低风险、标准化任务的半自动化执行。

• 安全报告自动生成
  AI Agent能够根据检测结果、日志分析过程和模型评估指标，自动生成安全分析报告、入侵检测实验报告或事件复盘材料。该能力有助于提升安全实验记录、攻防演练总结和日常运维汇报的规范化水平。

• 安全代码辅助开发
  在网络安全实验与工具开发中，AI Agent能够辅助完成数据读取、特征提取、模型训练、接口调用和可视化代码编写。结合CodeBuddy等AI编程工具，开发者可以更高效地构建入侵检测原型系统，降低安全算法实践门槛。

• 攻防演练辅助决策
  在红蓝对抗和攻防演练中，AI Agent可以辅助分析攻击路径、生成防守建议并总结演练过程中的薄弱环节。它并非替代安全专家，而是作为智能辅助工具提升攻防研判效率和复盘质量。

• 安全知识问答与培训
  AI Agent可基于安全知识库、漏洞案例和攻击技术框架，为学习者提供网络安全概念解释、实验步骤指导和问题排查建议。对于教学和培训场景而言，其能够降低网络安全学习门槛，并提升实践教学的交互性。

---

二.CodeBuddy自动构建机器学习IDS

下面介绍CodeBuddy调用大模型或智能体构建入侵检测模型代码的具体过程。整个流程如下图所示：

本文构建的数据集如下图所示，关键字段包括：

• payload_id：恶意请求payload编号
• attack_type：网络攻击类型，包括八种常见类型 XSS、SQLi、SSI、LDAPi等
• obfuscated_url：混淆恶意请求Payload
• url_n_gram：使用N-gram提取特征

第一步，在本地构建IDS目录（工程），打开CodeBuddy IDE。 其主界面如下图所示，打开该工程文件夹。在IDS工程中包含data文件夹，包含训练集、测试集和验证集3个CSV文件。

第二步，在右下角提示框中选择合适的大模型，并输入详细的提示词。 该提示词旨在读取数据集将特征转换为TF-IDF向量，并构建SVM机器学习算法进行分类，最终进行详细的入侵检测评估。

请在IDS目录下创建Python代码，该代码需要：
（1）读取data目录下train_features.csv、test_features.csv、val_features.csv文件，提取[payload_id、attack_type、url_n_gram]。
（2）提取attack_type特征作为类别，url_n_gram作为特征。
（3）将特征转换为TF-IDF向量形式。
（4）构建SVM算法进行分类。
（5）输出test_features.csv的预测结果，使用评价指标进行评估，并且保留3位小数，绘制相关评价可视化图。
（6）输出预测结果和正确结果的类别CSV文件。
（7）请给出MD实验分析总结报告，详细描述实验结果，评价结果增加八个类别的平均结果。

第三步，CodeBuddy调用GLM-5.1大模型深度思考，并构建如下图所示的3个关键代码生成任务。

• Create Python SVM classification script
• Run the script to generate results
• Generate MD experiment analysis report

CodeBuddy会生成详细的SVM代码，如下所示，点击Keep可以接受生成的代码。

第四步，CodeBuddy会自动运行代码并优化代码，下图展示了代码生成的结果。

此外，生成MD文档详细总结了实验结果内容，方便大家进行更详细的入侵检测评估。

SVM完整代码如下：

"""
基于TF-IDF和SVM的Web攻击类型分类实验
特征: url_n_gram
类别: attack_type
"""

import pandas as pd
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import SVC
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    classification_report, confusion_matrix
)
import warnings
import os
import time

warnings.filterwarnings('ignore')

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False

# ============================================================
# 1. 读取数据
# ============================================================
print("=" * 60)
print("步骤1: 读取数据")
print("=" * 60)

DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')

train_df = pd.read_csv(os.path.join(DATA_DIR, 'train_features.csv'))
test_df = pd.read_csv(os.path.join(DATA_DIR, 'test_features.csv'))
val_df = pd.read_csv(os.path.join(DATA_DIR, 'val_features.csv'))

print(f"训练集大小: {len(train_df)}")
print(f"验证集大小: {len(val_df)}")
print(f"测试集大小: {len(test_df)}")

# 提取指定列
cols = ['payload_id', 'attack_type', 'url_n_gram']
train_df = train_df[cols]
test_df = test_df[cols]
val_df = val_df[cols]

# 查看类别分布
print(f"\n训练集类别分布:")
print(train_df['attack_type'].value_counts())
print(f"\n测试集类别分布:")
print(test_df['attack_type'].value_counts())

# ============================================================
# 2. 特征提取与TF-IDF向量化
# ============================================================
print("\n" + "=" * 60)
print("步骤2: TF-IDF特征向量化")
print("=" * 60)

# 合并训练集和验证集作为训练数据
train_val_df = pd.concat([train_df, val_df], ignore_index=True)
X_train_text = train_val_df['url_n_gram'].fillna('')
y_train = train_val_df['attack_type']
X_test_text = test_df['url_n_gram'].fillna('')
y_test = test_df['attack_type']

# TF-IDF向量化
tfidf = TfidfVectorizer(
    max_features=10000,
    ngram_range=(1, 2),
    sublinear_tf=True,
    max_df=0.95,
    min_df=2
)

X_train_tfidf = tfidf.fit_transform(X_train_text)
X_test_tfidf = tfidf.transform(X_test_text)

print(f"TF-IDF特征维度: {X_train_tfidf.shape[1]}")
print(f"训练样本数: {X_train_tfidf.shape[0]}")
print(f"测试样本数: {X_test_tfidf.shape[0]}")

# 标签编码
le = LabelEncoder()
y_train_encoded = le.fit_transform(y_train)
y_test_encoded = le.transform(y_test)

class_names = le.classes_
print(f"类别数量: {len(class_names)}")
print(f"类别列表: {list(class_names)}")

# ============================================================
# 3. 构建SVM分类器
# ============================================================
print("\n" + "=" * 60)
print("步骤3: 构建SVM分类器并训练")
print("=" * 60)

start_time = time.time()
svm_model = SVC(
    kernel='rbf',
    C=10.0,
    gamma='scale',
    decision_function_shape='ovr',
    random_state=42
)
svm_model.fit(X_train_tfidf, y_train_encoded)
train_time = time.time() - start_time
print(f"训练时间: {train_time:.2f}秒")

# ============================================================
# 4. 预测与评估
# ============================================================
print("\n" + "=" * 60)
print("步骤4: 模型预测与评估")
print("=" * 60)

start_time = time.time()
y_pred_encoded = svm_model.predict(X_test_tfidf)
predict_time = time.time() - start_time
print(f"预测时间: {predict_time:.2f}秒")

y_pred = le.inverse_transform(y_pred_encoded)

# 整体评价指标
accuracy = accuracy_score(y_test, y_pred)
precision_macro = precision_score(y_test, y_pred, average='macro')
recall_macro = recall_score(y_test, y_pred, average='macro')
f1_macro = f1_score(y_test, y_pred, average='macro')

precision_weighted = precision_score(y_test, y_pred, average='weighted')
recall_weighted = recall_score(y_test, y_pred, average='weighted')
f1_weighted = f1_score(y_test, y_pred, average='weighted')

print(f"\n整体评价指标（保留3位小数）:")
print(f"  准确率 (Accuracy):           {accuracy:.3f}")
print(f"  宏精确率 (Precision-Macro):   {precision_macro:.3f}")
print(f"  宏召回率 (Recall-Macro):      {recall_macro:.3f}")
print(f"  宏F1值 (F1-Macro):           {f1_macro:.3f}")
print(f"  加权精确率 (Precision-Wtd):   {precision_weighted:.3f}")
print(f"  加权召回率 (Recall-Wtd):      {recall_weighted:.3f}")
print(f"  加权F1值 (F1-Wtd):           {f1_weighted:.3f}")

# 分类报告
print(f"\n详细分类报告:")
report = classification_report(y_test, y_pred, target_names=class_names, digits=3)
print(report)

# 各类别指标
precision_per_class = precision_score(y_test, y_pred, average=None, labels=class_names)
recall_per_class = recall_score(y_test, y_pred, average=None, labels=class_names)
f1_per_class = f1_score(y_test, y_pred, average=None, labels=class_names)

print(f"\n各类别详细指标（保留3位小数）:")
print(f"{'类别':<20s} {'精确率':>8s} {'召回率':>8s} {'F1值':>8s}")
print("-" * 48)
for i, cls in enumerate(class_names):
    print(f"{cls:<20s} {precision_per_class[i]:>8.3f} {recall_per_class[i]:>8.3f} {f1_per_class[i]:>8.3f}")
print("-" * 48)
print(f"{'宏平均':<20s} {precision_macro:>8.3f} {recall_macro:>8.3f} {f1_macro:>8.3f}")
print(f"{'加权平均':<20s} {precision_weighted:>8.3f} {recall_weighted:>8.3f} {f1_weighted:>8.3f}")

# ============================================================
# 5. 绘制可视化图
# ============================================================
print("\n" + "=" * 60)
print("步骤5: 绘制评价可视化图")
print("=" * 60)

OUTPUT_DIR = os.path.dirname(os.path.abspath(__file__))

# --- 5.1 混淆矩阵 ---
cm = confusion_matrix(y_test, y_pred, labels=class_names)
plt.figure(figsize=(12, 10))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=class_names, yticklabels=class_names)
plt.title('Confusion Matrix - SVM (TF-IDF url_n_gram)', fontsize=14)
plt.xlabel('Predicted Label', fontsize=12)
plt.ylabel('True Label', fontsize=12)
plt.xticks(rotation=45, ha='right')
plt.yticks(rotation=0)
plt.tight_layout()
cm_path = os.path.join(OUTPUT_DIR, 'confusion_matrix.png')
plt.savefig(cm_path, dpi=150)
plt.close()
print(f"混淆矩阵已保存: {cm_path}")

# --- 5.2 归一化混淆矩阵 ---
cm_norm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
plt.figure(figsize=(12, 10))
sns.heatmap(cm_norm, annot=True, fmt='.3f', cmap='Blues',
            xticklabels=class_names, yticklabels=class_names)
plt.title('Normalized Confusion Matrix - SVM (TF-IDF url_n_gram)', fontsize=14)
plt.xlabel('Predicted Label', fontsize=12)
plt.ylabel('True Label', fontsize=12)
plt.xticks(rotation=45, ha='right')
plt.yticks(rotation=0)
plt.tight_layout()
cm_norm_path = os.path.join(OUTPUT_DIR, 'confusion_matrix_normalized.png')
plt.savefig(cm_norm_path, dpi=150)
plt.close()
print(f"归一化混淆矩阵已保存: {cm_norm_path}")

# --- 5.3 各类别Precision/Recall/F1柱状图 ---
x = np.arange(len(class_names))
width = 0.25

fig, ax = plt.subplots(figsize=(14, 7))
bars1 = ax.bar(x - width, precision_per_class, width, label='Precision', color='#4C72B0')
bars2 = ax.bar(x, recall_per_class, width, label='Recall', color='#DD8452')
bars3 = ax.bar(x + width, f1_per_class, width, label='F1-Score', color='#55A868')

ax.set_xlabel('Attack Type', fontsize=12)
ax.set_ylabel('Score', fontsize=12)
ax.set_title('Per-Class Precision / Recall / F1-Score - SVM (TF-IDF url_n_gram)', fontsize=14)
ax.set_xticks(x)
ax.set_xticklabels(class_names, rotation=45, ha='right')
ax.set_ylim(0, 1.1)
ax.legend()
ax.grid(axis='y', alpha=0.3)

# 在柱状图上标注数值
for bars in [bars1, bars2, bars3]:
    for bar in bars:
        height = bar.get_height()
        if height > 0.01:
            ax.annotate(f'{height:.2f}',
                        xy=(bar.get_x() + bar.get_width() / 2, height),
                        xytext=(0, 3), textcoords="offset points",
                        ha='center', va='bottom', fontsize=7)

plt.tight_layout()
bar_path = os.path.join(OUTPUT_DIR, 'per_class_metrics.png')
plt.savefig(bar_path, dpi=150)
plt.close()
print(f"各类别指标柱状图已保存: {bar_path}")

# --- 5.4 测试集类别分布对比 ---
test_counts = test_df['attack_type'].value_counts().reindex(class_names)
pred_counts = pd.Series(y_pred).value_counts().reindex(class_names, fill_value=0)

fig, ax = plt.subplots(figsize=(12, 6))
x_idx = np.arange(len(class_names))
width = 0.35
ax.bar(x_idx - width/2, test_counts.values, width, label='True Distribution', color='#4C72B0')
ax.bar(x_idx + width/2, pred_counts.values, width, label='Predicted Distribution', color='#DD8452')
ax.set_xlabel('Attack Type', fontsize=12)
ax.set_ylabel('Count', fontsize=12)
ax.set_title('True vs Predicted Distribution - Test Set', fontsize=14)
ax.set_xticks(x_idx)
ax.set_xticklabels(class_names, rotation=45, ha='right')
ax.legend()
ax.grid(axis='y', alpha=0.3)
plt.tight_layout()
dist_path = os.path.join(OUTPUT_DIR, 'distribution_comparison.png')
plt.savefig(dist_path, dpi=150)
plt.close()
print(f"类别分布对比图已保存: {dist_path}")

# --- 5.5 综合评价雷达图 ---
from math import pi

# 计算每个类别的综合得分
categories_count = len(class_names)
scores = {
    'Precision': precision_per_class,
    'Recall': recall_per_class,
    'F1-Score': f1_per_class
}

fig, axes = plt.subplots(1, 3, figsize=(20, 7), subplot_kw=dict(polar=True))
for idx, (metric_name, values) in enumerate(scores.items()):
    ax = axes[idx]
    angles = [n / float(categories_count) * 2 * pi for n in range(categories_count)]
    values_plot = list(values) + [values[0]]
    angles += angles[:1]
    
    ax.plot(angles, values_plot, 'o-', linewidth=2, color=['#4C72B0', '#DD8452', '#55A868'][idx])
    ax.fill(angles, values_plot, alpha=0.25, color=['#4C72B0', '#DD8452', '#55A868'][idx])
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(class_names, fontsize=8)
    ax.set_ylim(0, 1.1)
    ax.set_title(metric_name, fontsize=14, pad=20)

plt.suptitle('Per-Class Metric Radar Charts - SVM (TF-IDF url_n_gram)', fontsize=16, y=1.05)
plt.tight_layout()
radar_path = os.path.join(OUTPUT_DIR, 'radar_charts.png')
plt.savefig(radar_path, dpi=150, bbox_inches='tight')
plt.close()
print(f"雷达图已保存: {radar_path}")

# ============================================================
# 6. 输出预测结果CSV
# ============================================================
print("\n" + "=" * 60)
print("步骤6: 输出预测结果CSV")
print("=" * 60)

result_df = pd.DataFrame({
    'payload_id': test_df['payload_id'].values,
    'true_label': y_test.values,
    'predicted_label': y_pred
})
result_df['correct'] = (result_df['true_label'] == result_df['predicted_label']).astype(int)

result_path = os.path.join(OUTPUT_DIR, 'prediction_results.csv')
result_df.to_csv(result_path, index=False, encoding='utf-8-sig')
print(f"预测结果已保存: {result_path}")

# 打印前10条
print(f"\n预测结果前10条:")
print(result_df.head(10).to_string(index=False))

# ============================================================
# 7. 生成MD实验分析报告
# ============================================================
print("\n" + "=" * 60)
print("步骤7: 生成MD实验分析报告")
print("=" * 60)

# 计算八个类别的平均结果
avg_precision = np.mean(precision_per_class)
avg_recall = np.mean(recall_per_class)
avg_f1 = np.mean(f1_per_class)

# 各类别样本数
test_class_counts = test_df['attack_type'].value_counts()
train_class_counts = train_val_df['attack_type'].value_counts()

# 混淆矩阵中各类别的正确分类数和错误分类数
correct_per_class = np.diag(cm)
total_per_class = cm.sum(axis=1)
error_per_class = total_per_class - correct_per_class
accuracy_per_class = correct_per_class / total_per_class

md_content = f"""# Web攻击类型分类实验分析报告

## 1. 实验概述

本实验基于Web攻击载荷的 `url_n_gram` 特征，使用TF-IDF向量化方法将文本特征转换为数值向量，并采用支持向量机（SVM）算法进行多类别分类，以识别不同类型的Web攻击。

### 1.1 实验目标
- 基于URL的n-gram特征构建攻击类型分类模型
- 评估SVM算法在Web攻击分类任务上的性能
- 分析各类别的分类效果和混淆情况

### 1.2 数据集说明

| 数据集 | 样本数 |
|--------|--------|
| 训练集（train + val） | {len(train_val_df)} |
| 测试集 | {len(test_df)} |

### 1.3 类别分布

| 攻击类型 | 训练集样本数 | 测试集样本数 |
|----------|-------------|-------------|
"""

for cls in class_names:
    tr_cnt = train_class_counts.get(cls, 0)
    te_cnt = test_class_counts.get(cls, 0)
    md_content += f"| {cls} | {tr_cnt} | {te_cnt} |\n"

md_content += f"""
## 2. 实验方法

### 2.1 特征提取
- **特征选择**: `url_n_gram`（URL的n-gram特征）
- **向量化方法**: TF-IDF（Term Frequency-Inverse Document Frequency）
- **TF-IDF参数**:
  - 最大特征数: 10,000
  - n-gram范围: (1, 2)
  - 使用sublinear_tf: True
  - 最大文档频率: 0.95
  - 最小文档频率: 2

### 2.2 分类算法
- **算法**: 支持向量机（SVM）
- **核函数**: RBF（径向基函数）
- **正则化参数C**: 10.0
- **gamma**: scale
- **决策函数**: OvR（One-vs-Rest）
- **训练时间**: {train_time:.2f}秒
- **预测时间**: {predict_time:.2f}秒

## 3. 实验结果

### 3.1 整体评价指标

| 评价指标 | 值 |
|----------|-----|
| 准确率 (Accuracy) | {accuracy:.3f} |
| 宏精确率 (Macro Precision) | {precision_macro:.3f} |
| 宏召回率 (Macro Recall) | {recall_macro:.3f} |
| 宏F1值 (Macro F1-Score) | {f1_macro:.3f} |
| 加权精确率 (Weighted Precision) | {precision_weighted:.3f} |
| 加权召回率 (Weighted Recall) | {recall_weighted:.3f} |
| 加权F1值 (Weighted F1-Score) | {f1_weighted:.3f} |

### 3.2 各类别详细评价

| 攻击类型 | 精确率 | 召回率 | F1值 | 测试样本数 | 正确分类数 | 错误分类数 | 类别准确率 |
|----------|--------|--------|------|-----------|-----------|-----------|-----------|
"""

for i, cls in enumerate(class_names):
    md_content += (f"| {cls} | {precision_per_class[i]:.3f} | {recall_per_class[i]:.3f} "
                   f"| {f1_per_class[i]:.3f} | {total_per_class[i]} | {correct_per_class[i]} "
                   f"| {error_per_class[i]} | {accuracy_per_class[i]:.3f} |\n")

md_content += f"""
### 3.3 八个类别的平均结果

| 指标 | 八类平均 |
|------|---------|
| 平均精确率 | {avg_precision:.3f} |
| 平均召回率 | {avg_recall:.3f} |
| 平均F1值 | {avg_f1:.3f} |

### 3.4 混淆矩阵分析

混淆矩阵展示了各类别之间的误分类情况，对角线元素表示正确分类的样本数，非对角线元素表示误分类的样本数。

详细的混淆矩阵数据如下：

| 真实\\预测 | {' | '.join(class_names)} |
|-----------|{'|' * len(class_names)}
"""

for i, cls_true in enumerate(class_names):
    row_vals = ' | '.join([f"{cm[i][j]}" for j in range(len(class_names))])
    md_content += f"| {cls_true} | {row_vals} |\n"

md_content += f"""
## 4. 可视化分析

实验生成了以下可视化图表：

1. **混淆矩阵** (`confusion_matrix.png`): 展示各类别间的分类情况
2. **归一化混淆矩阵** (`confusion_matrix_normalized.png`): 以比例形式展示分类情况
3. **各类别指标柱状图** (`per_class_metrics.png`): 对比各类别的Precision/Recall/F1
4. **类别分布对比图** (`distribution_comparison.png`): 真实标签与预测标签的分布对比
5. **雷达图** (`radar_charts.png`): 各类别指标的雷达图可视化

## 5. 实验分析与讨论

### 5.1 模型整体性能
- 模型整体准确率为 **{accuracy:.3f}**，宏F1值为 **{f1_macro:.3f}**，说明SVM结合TF-IDF特征在Web攻击分类任务上具有良好的分类能力。

### 5.2 各类别分析
"""

# 分析表现最好的类别
best_idx = np.argmax(f1_per_class)
worst_idx = np.argmin(f1_per_class)
md_content += f"- 表现最好的类别: **{class_names[best_idx]}**（F1={f1_per_class[best_idx]:.3f}）\n"
md_content += f"- 表现最差的类别: **{class_names[worst_idx]}**（F1={f1_per_class[worst_idx]:.3f}）\n\n"

# 分析混淆情况
md_content += "### 5.3 主要混淆情况\n\n"
# 找出混淆矩阵中最大的非对角线元素
cm_copy = cm.copy().astype(float)
np.fill_diagonal(cm_copy, 0)
top_confusions = []
for _ in range(min(5, len(class_names))):
    max_idx = np.unravel_index(np.argmax(cm_copy), cm_copy.shape)
    if cm_copy[max_idx] == 0:
        break
    top_confusions.append((class_names[max_idx[0]], class_names[max_idx[1]], int(cm_copy[max_idx])))
    cm_copy[max_idx] = 0

if top_confusions:
    md_content += "| 真实类别 | 误判为 | 误判数量 |\n|---------|--------|----------|\n"
    for true_cls, pred_cls, cnt in top_confusions:
        md_content += f"| {true_cls} | {pred_cls} | {cnt} |\n"
    md_content += "\n"

md_content += f"""
### 5.4 八类平均结果分析
- 八个类别的平均精确率为 **{avg_precision:.3f}**，平均召回率为 **{avg_recall:.3f}**，平均F1值为 **{avg_f1:.3f}**。
- 平均结果与宏平均（Macro Average）结果一致，反映了模型在各类别上的均衡表现。

### 5.5 实验结论
1. SVM + TF-IDF方法在Web攻击分类任务上取得了较好的效果，整体准确率达到{accuracy:.3f}。
2. url_n_gram特征能够有效区分不同类型的Web攻击，n-gram特征捕获了URL中的关键模式。
3. 部分类别之间存在一定混淆，这可能与攻击载荷的相似性有关（如SQL注入和LDAP注入等注入类攻击）。
4. RBF核函数能够处理特征空间中的非线性决策边界，适合此多类别分类任务。

## 6. 输出文件说明

| 文件名 | 描述 |
|--------|------|
| `prediction_results.csv` | 测试集预测结果（含payload_id、真实标签、预测标签、是否正确） |
| `confusion_matrix.png` | 混淆矩阵可视化 |
| `confusion_matrix_normalized.png` | 归一化混淆矩阵可视化 |
| `per_class_metrics.png` | 各类别Precision/Recall/F1柱状图 |
| `distribution_comparison.png` | 真实vs预测分布对比图 |
| `radar_charts.png` | 各类别指标雷达图 |
| `svm_classification.py` | 实验源代码 |
| `experiment_report.md` | 本实验分析报告 |
"""

report_path = os.path.join(OUTPUT_DIR, 'experiment_report.md')
with open(report_path, 'w', encoding='utf-8') as f:
    f.write(md_content)
print(f"实验报告已保存: {report_path}")

print("\n" + "=" * 60)
print("实验完成!")
print("=" * 60)

---

三.CodeBuddy自动构建深度学习IDS

同样的方法利用CodeBuddy构建深度学习IDS，具体步骤如下：

第一步，在CodeBuddy中输入详细的提示词并运行。

第二步，大模型经过深度思考生成CNN代码。

运行结果如下图所示：

关键代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
CNN URL分类实验 (PyTorch)
使用url_n_gram特征训练CNN模型进行攻击类型分类
预期Macro F1值：约0.85-0.92
"""

import os
import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import classification_report, accuracy_score, precision_recall_fscore_support, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.feature_extraction.text import TfidfVectorizer
import warnings
warnings.filterwarnings('ignore')

# ==================== 配置参数 ====================
# 文件路径（相对路径）
TRAIN_FILE = '../data_hx/train_features.csv'
VAL_FILE = '../data_hx/val_features.csv'
TEST_FILE = '../data_hx/test_features.csv'

# 输出目录
OUTPUT_DIR = 'output'

# 模型参数
MAX_FEATURES = 5000      # TF-IDF特征维度
EMBEDDING_DIM = 128     # 嵌入维度
CNN_OUT_CHANNELS = 128   # CNN输出通道数
KERNEL_SIZES = [3, 4, 5]  # 卷积核大小
DROPOUT_RATE = 0.5      # Dropout率
LEARNING_RATE = 0.001    # 学习率
BATCH_SIZE = 64          # 批次大小
NUM_EPOCHS = 20         # 训练轮数
RANDOM_SEED = 42        # 随机种子

# ==================== 设备配置 ====================
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用设备: {device}")

# ==================== 步骤1: 读取数据 ====================
def load_data():
    """读取CSV文件并提取所需特征"""
    print("=" * 80)
    print("步骤1: 读取数据")
    print("=" * 80)
    
    # 读取CSV文件
    train_df = pd.read_csv(TRAIN_FILE)
    val_df = pd.read_csv(VAL_FILE)
    test_df = pd.read_csv(TEST_FILE)
    
    print(f"训练集大小: {len(train_df)}")
    print(f"验证集大小: {len(val_df)}")
    print(f"测试集大小: {len(test_df)}")
    
    # 提取所需列
    required_columns = ['payload_id', 'attack_type', 'obfuscated_url', 'url_n_gram']
    
    train_df = train_df[required_columns]
    val_df = val_df[required_columns]
    test_df = test_df[required_columns]
    
    print(f"\n提取的列: {required_columns}")
    print(f"训练集类别分布:")
    print(train_df['attack_type'].value_counts())
    
    return train_df, val_df, test_df

# ==================== 步骤2: 特征工程 ====================
def prepare_features(train_df, val_df, test_df):
    """准备特征：将url_n_gram转换为向量"""
    print("\n" + "=" * 80)
    print("步骤2: 特征工程")
    print("=" * 80)
    
    # 使用TF-IDF向量化url_n_gram
    print("使用TF-IDF进行特征向量化...")
    
    # 初始化TF-IDF向量化器
    tfidf = TfidfVectorizer(
        max_features=MAX_FEATURES,
        min_df=2,
        max_df=0.95,
        ngram_range=(1, 2)
    )
    
    # 拟合训练数据
    X_train_tfidf = tfidf.fit_transform(train_df['url_n_gram']).toarray()
    X_val_tfidf = tfidf.transform(val_df['url_n_gram']).toarray()
    X_test_tfidf = tfidf.transform(test_df['url_n_gram']).toarray()
    
    print(f"TF-IDF特征维度: {X_train_tfidf.shape[1]}")
    print(f"训练集特征形状: {X_train_tfidf.shape}")
    print(f"验证集特征形状: {X_val_tfidf.shape}")
    print(f"测试集特征形状: {X_test_tfidf.shape}")
    
    # 编码标签
    label_encoder = LabelEncoder()
    y_train = label_encoder.fit_transform(train_df['attack_type'])
    y_val = label_encoder.transform(val_df['attack_type'])
    y_test = label_encoder.transform(test_df['attack_type'])
    
    print(f"\n类别数量: {len(label_encoder.classes_)}")
    print(f"类别标签: {label_encoder.classes_}")
    
    return X_train_tfidf, X_val_tfidf, X_test_tfidf, y_train, y_val, y_test, label_encoder, tfidf

# ==================== 步骤3: 创建数据集类 ====================
class URLDataset(Dataset):
    """自定义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]

# ==================== 步骤4: 构建CNN模型 ====================
class CNNClassifier(nn.Module):
    """CNN分类器"""
    def __init__(self, input_dim, num_classes, embedding_dim=EMBEDDING_DIM, 
                 cnn_out_channels=CNN_OUT_CHANNELS, kernel_sizes=KERNEL_SIZES, 
                 dropout_rate=DROPOUT_RATE):
        super(CNNClassifier, self).__init__()
        
        # 嵌入层（将TF-IDF特征映射到稠密向量）
        self.embedding = nn.Linear(input_dim, embedding_dim)
        
        # 添加通道维度（用于1D卷积）
        self.conv1 = nn.Conv1d(1, cnn_out_channels, kernel_size=kernel_sizes[0], padding=kernel_sizes[0]//2)
        self.conv2 = nn.Conv1d(1, cnn_out_channels, kernel_size=kernel_sizes[1], padding=kernel_sizes[1]//2)
        self.conv3 = nn.Conv1d(1, cnn_out_channels, kernel_size=kernel_sizes[2], padding=kernel_sizes[2]//2)
        
        # 批归一化
        self.bn1 = nn.BatchNorm1d(cnn_out_channels)
        self.bn2 = nn.BatchNorm1d(cnn_out_channels)
        self.bn3 = nn.BatchNorm1d(cnn_out_channels)
        
        # Dropout
        self.dropout = nn.Dropout(dropout_rate)
        
        # 全连接层
        self.fc = nn.Linear(cnn_out_channels * len(kernel_sizes), num_classes)
        
        # 激活函数
        self.relu = nn.ReLU()
    
    def forward(self, x):
        # x shape: (batch_size, input_dim)
        x = self.embedding(x)  # (batch_size, embedding_dim)
        x = x.unsqueeze(1)  # 添加通道维度: (batch_size, 1, embedding_dim)
        
        # 多个卷积核
        x1 = self.relu(self.bn1(self.conv1(x)))
        x2 = self.relu(self.bn2(self.conv2(x)))
        x3 = self.relu(self.bn3(self.conv3(x)))
        
        # 全局最大池化
        x1 = torch.max(x1, dim=2)[0]
        x2 = torch.max(x2, dim=2)[0]
        x3 = torch.max(x3, dim=2)[0]
        
        # 拼接
        x = torch.cat((x1, x2, x3), dim=1)
        x = self.dropout(x)
        x = self.fc(x)
        
        return x

# ==================== 步骤5: 训练模型 ====================
def train_model(model, train_loader, val_loader, criterion, optimizer, num_epochs, device):
    """训练模型"""
    print(f"\n训练完成！最终验证准确率: {val_accuracies[-1]:.4f}")
    return train_losses, val_accuracies

# ==================== 步骤6: 评估模型 ====================
def evaluate_model(model, test_loader, label_encoder, device):
    """评估模型"""
    return all_predictions, all_labels, accuracy, macro_f1, weighted_f1

# ==================== 步骤7: 保存结果 ====================
def save_results(test_df, all_predictions, all_labels, label_encoder, accuracy, macro_f1, weighted_f1):
    """保存预测结果"""

# ==================== 步骤8: 绘制可视化图表 ====================
def plot_visualizations(all_labels, all_predictions, label_encoder, train_losses, val_accuracies):
    """绘制评估可视化图表"""

# ==================== 步骤9: 生成实验报告 ====================
def generate_report(test_df, all_predictions, all_labels, label_encoder, accuracy, macro_f1, weighted_f1, train_losses, val_accuracies):
    """生成Markdown实验报告"""


# ==================== 主函数 ====================
def main():
    """主函数"""
    print("=" * 80)
    print("CNN URL分类实验 (PyTorch)")
    print("=" * 80)
    
    # 设置随机种子
    torch.manual_seed(RANDOM_SEED)
    np.random.seed(RANDOM_SEED)
    
    # 步骤1: 读取数据
    train_df, val_df, test_df = load_data()
    
    # 步骤2: 特征工程
    X_train, X_val, X_test, y_train, y_val, y_test, label_encoder, tfidf = prepare_features(
        train_df, val_df, test_df
    )
    
    # 步骤3: 创建数据集和数据加载器
    train_dataset = URLDataset(X_train, y_train)
    val_dataset = URLDataset(X_val, y_val)
    test_dataset = URLDataset(X_test, y_test)
    
    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)
    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)
    
    # 步骤4: 构建模型
    num_classes = len(label_encoder.classes_)
    model = CNNClassifier(
        input_dim=MAX_FEATURES,
        num_classes=num_classes
    )
    print(f"\n模型架构:")
    print(model)
    
    # 步骤5: 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
    
    # 步骤6: 训练模型
    train_losses, val_accuracies = train_model(
        model, train_loader, val_loader, criterion, optimizer, NUM_EPOCHS, device
    )
    
    # 步骤7: 评估模型
    all_predictions, all_labels, accuracy, macro_f1, weighted_f1 = evaluate_model(
        model, test_loader, label_encoder, device
    )
    
    # 步骤8: 保存结果
    save_results(test_df, all_predictions, all_labels, label_encoder, accuracy, macro_f1, weighted_f1)
    
    # 步骤9: 绘制可视化图表
    plot_visualizations(all_labels, all_predictions, label_encoder, train_losses, val_accuracies)
    
    # 步骤10: 生成实验报告
    generate_report(test_df, all_predictions, all_labels, label_encoder, accuracy, macro_f1, weighted_f1, train_losses, val_accuracies)
    
    print("\n" + "=" * 80)
    print("实验完成！")
    print("=" * 80)
    print(f"\n所有输出文件已保存到: {OUTPUT_DIR}")
    print(f"Macro F1-Score: {macro_f1:.4f}")
    print(f"Accuracy: {accuracy:.4f}")

if __name__ == '__main__':
    main()

此外，我们可以将CodeBuddy生成的代码放在服务器或云端运行，更好地实现入侵检测。

---

四.云端d.run运行深度学习入侵检测系统

在完成CodeBuddy辅助生成深度学习入侵检测代码之后，下一步需要将代码部署到可运行的实验环境中进行验证。考虑到深度学习模型通常对Python环境、依赖库、计算资源和文件路径具有一定要求，如果完全在本地配置环境，容易出现依赖冲突、版本不一致或算力不足等问题。

因此，本文选择使用云端d.run平台作为实验运行环境，通过云端算力完成代码上传、依赖安装、数据读取、模型训练和结果输出等操作。该过程能够有效降低本地环境配置成本，也便于后续复现实验流程。

1.配置d.run平台

d.run作为云端计算平台，能够为用户提供在线算力实例、文件管理、终端运行和环境配置等功能。在本实验中，主要借助其云端容器环境运行深度学习入侵检测代码。

• https://www.d.run/compute-market/cloud

主界面如下图所示：

第一步，进入d.run平台的云端计算资源页面，选择适合当前实验任务的计算环境。 在平台配置过程中，需要重点关注实例创建、镜像环境、存储空间和终端入口等内容。

对于本次网络入侵检测实验而言，主要任务是运行基于CNN的深度学习分类模型，因此对环境的核心要求包括Python运行环境、基础数据分析库支持，以及能够完成模型训练和结果可视化的计算资源。相比大型大模型训练任务，本实验的数据规模和模型复杂度相对可控，因此选择常规云端计算实例即可满足基本实验需求。

第二步，在算力市场中选择合适的模型，比如GPU NVIDIA GeForce-RTX-4090。

创建实例后，系统会为用户分配一个独立的云端运行环境，用户可以在该环境中上传代码文件、管理数据目录，并通过命令行执行Python程序。相比本地电脑，云端环境的优势在于配置过程更加标准化，能够减少不同操作系统、不同Python版本和不同依赖库带来的兼容性问题。

第三步，开启云端服务器并将本地项目文件上传至d.run环境中。

读者可以选择SSH登录或其它方式登录，作者习惯点击JupyterLab通过网页访问服务器。

此外，点击扩展按钮可以控制该容器。

第四步，在弹出的JupyterLab页面中创建Python代码。

此外，读者可以利用d.run进行大模型的安全实验。

---

2.运行深度学习代码

在实际操作中，建议将代码和数据按照清晰的项目结构进行组织。例如，可以将入侵检测代码统一放置在IDS目录下，将训练数据放置在data_hx目录下。这样不仅便于后续运行命令时定位脚本，也有利于保持项目结构规范，方便读者复现实验过程。

project/
├── IDS/
│   └── cnn_ids.py
└── data/
    └── train_features.csv

主界面如下图所示：

第一步，创建工程IDS。

第二步，将代码及数据集拖动至d.run网页。

数据集如下图所示：

第三步，通过New -> Terminal 能运行该python代码。

第四步，在终端输入如下指令运行代码。

python IDS/cnn_url_classification.py

温馨提示：
如果代码提示存在未安装的扩展包，通过pip命令即可安装。如：pip install pandas。

其它安装指令包括：

• pip install scikit-learn
• pip install matplotlib
• pip install seaborn

最终运行代码如下：

cd IDS
python cnn_url_classification.py

运行结果如下图所示：

此外，云端将生成实验结果和MD报告。

此外，读者可以结合自身内容进行详细的对比实验，无论是科学研究还是实战系统，均可进行赋能。

总体来看，本部分完成了深度学习入侵检测系统在云端环境中的配置与运行。通过上传项目代码、组织数据目录、安装依赖库和执行训练脚本，实验实现了从本地代码到云端验证的迁移。该过程说明，AI Agent与云端计算平台的结合能够有效提升网络安全实验的开发效率，为后续开展更复杂的入侵检测、恶意流量识别和安全数据分析任务提供了基础支撑。

---

五.总结及新书推荐

本文围绕“AI Agent赋能网络入侵检测”展开实践探索，以CodeBuddy和d.run为核心工具，系统展示了从安全任务理解、代码辅助生成到云端运行验证的完整流程。文章首先概述了AI Agent在网络安全中的典型应用场景，说明其能够在威胁检测、日志分析、漏洞研判、攻击链溯源和安全报告生成等环节发挥辅助作用；随后以入侵检测为具体案例，借助CodeBuddy生成深度学习检测代码，并通过d.run云端平台完成环境配置、依赖安装、数据上传、模型训练和结果分析。整体来看，本文不仅体现了大模型在安全编程与实验复现中的效率优势，也说明了AI Agent与云端算力平台结合后，能够有效降低网络安全算法实践门槛，为后续开展智能化攻防实验、入侵检测模型优化和安全自动化分析提供了可复用的技术路径。

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

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

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

为什么首选CodeBuddy？

• 其一，CodeBuddy以“产品—设计—研发”一体化协作为核心理念，将大语言模型深度融入需求表达、界面设计、代码生成与云端部署全流程，真正实现自然语言驱动开发，让创意快速落地；
• 其二，CodeBuddy支持一键对接腾讯云CloudBase、Supabase等服务，便于项目构建与部署；
• 其三，CodeBuddy依托腾讯在AI与开发者生态方面的积累，结合MCP、多智能体等前沿能力，不仅支持高效应用开发，更具备构建复杂智能系统的潜力。

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

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

2024年4月28日是Eastmount的安全星球——『网络攻防和AI安全之家』正式创建和运营的日子，该星球目前主营业务为 安全零基础答疑、安全技术分享、AI安全技术分享、AI安全论文交流、威胁情报每日推送、网络攻防技术总结、系统安全技术实战、面试求职、安全考研考博、简历修改及润色、学术交流及答疑、人脉触达、认知提升等。下面是星球的新人券，欢迎新老博友和朋友加入，一起分享更多安全知识，比较良心的星球，非常适合初学者和换安全专业的读者学习。

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

(By:Eastmount 2026-05-06 周三写于贵阳 http://blog.csdn.net/eastmount/ )

---