娜璋AI安全之家

十年磨一剑！《Python文本挖掘和知识发现》重磅上市：从文本挖掘到大模型，探索知识发现新范式

Sat, 29 Aug 2026 20:30:00 +0800

原创 Eastmount 2026-08-29 20:30 贵州

新书重磅上市，干货满满！评论点赞抽奖

《Python文本挖掘和知识发现：大模型时代的新挑战与探索》重磅上市！ 本书由长期深耕人工智能、文本挖掘、知识图谱与网络安全等领域的一线教师和科研人员联合编写，凝聚团队十余年的AI研究、教学与实践积累，由北京航空航天大学出版社正式出版。

全书围绕“如何从海量文本中挖掘有价值的信息、如何构建高质量特征与智能模型、如何将大模型应用于真实业务场景”三大核心问题展开，系统融汇文本表示、词法句法语义分析、文本分类与聚类、情感分析、主题挖掘、知识图谱、智能问答、大语言模型、RAG与GraphRAG等内容，力求打通从文本数据处理、语义理解到知识发现与智能服务的完整技术链路。

十年磨一剑，从传统文本挖掘一路走到大模型时代，我们想写的并不是一本简单罗列算法和代码的工具书，而是一部帮助读者建立完整文本智能知识体系的实战教材。无论你是刚刚接触Python、自然语言处理和人工智能的初学者，还是正在开展文本分析、知识图谱、数字人文、情报分析、网络安全和大模型研究的高校师生、科研人员与开发者，都可以沿着本书“起始—基础—高阶”的学习路径，从零开始理解文本、分析文本、挖掘文本，并最终把散落在海量文本中的信息转化为可组织、可关联、可计算、可利用的知识。我们更希望通过这本书回答一个大模型时代绕不开的问题：当ChatGPT、DeepSeek等大模型已经能够阅读、总结甚至生成文本，我们为什么还需要学习文本挖掘与知识发现？

近700页内容、200个实战案例、17个章节，从撰写到见刊历经6年
云南大学一位老教授感叹“现在年轻科研人很难做到这么深耕一门技术呀！”

文章目录

🎁 新书上市福利：评论点赞最高的3位读者赠书
十年磨一剑：为什么我们还要在大模型时代写一本“文本挖掘”？
一、大模型不是终点，而是文本挖掘与知识发现的新起点
二、从0到1：一条贯通“文本—信息—知识—智能”的学习路线
三、从“文本挖掘”到“发现知识”：本书真正想训练的核心能力
四、理论、代码与案例并重：不只“看懂”，更要真正“做出来”
五、五大核心亮点：为什么这本书值得关注？
六、哪些人适合阅读这本书？
七、一本书出版不是结束，而是持续生长的开始
写在最后：真正稀缺的，是从文本中发现知识的能力

🎁 新书上市福利：评论点赞最高的3位读者赠书

在正式介绍本书之前，先给一直关注和支持我们的读者送上一份小福利。

欢迎大家在评论区留言，说说你与Python、文本挖掘、知识图谱或大模型的故事，也可以谈谈你最希望从这本书中学到什么，或者与本书作者的故事。活动结束后（公众号截止9月5日晚），我们将从评论区中选取点赞数最高的3位读者，每人赠送《Python文本挖掘和知识发现：大模型时代的新挑战与探索》一本。

希望这3本书能真正送到热爱技术、愿意动手实践的朋友手中。一本技术书最好的价值，不只是被摆在书架上，而是能够真正变成代码、实验、论文、项目，以及解决现实问题的能力。

京东和当当网搜索“Python文本挖掘和知识发现” 或者搜索作者名字“杨秀璋”即可购买。具体地址如下：

https://item.jd.com/15421864.html

十年磨一剑：为什么我们还要在大模型时代写一本“文本挖掘”？

过去十余年，AI领域发生了翻天覆地的变化。

从早期依赖统计特征的文本分析，到机器学习；从Word2Vec等词嵌入技术，到CNN、RNN、Transformer和BERT；再到今天以ChatGPT、DeepSeek等为代表的大语言模型，机器处理文本的能力已经发生质的飞跃。

于是，一个很自然的问题出现了：

既然大模型已经这么强，为什么还要学习文本挖掘？

这也是我们在构思本书时反复思考的问题。

今天，人类生产的信息依然大量以非结构化文本存在，包括学术论文、新闻报道、政策文件、社交媒体、历史文献、网络评论、企业报告和网络威胁情报等。这些文本规模庞大、结构复杂、语义丰富，其中蕴含着大量有价值的信息和知识。

但“文本存在”并不意味着“知识已经被发现”。

真正的科研与工程应用，仍然需要回答：如何清洗和组织海量语料？如何理解文本语义？如何识别人名、机构、地点、事件等实体？如何发现实体之间的关系？如何从文本中提取主题并分析其演化？又如何把零散信息进一步组织成知识，并支撑检索、问答和智能决策？

因此，大模型并没有让文本挖掘失去价值，反而推动文本挖掘进入了新的阶段。

本书《前言》中用一条非常清晰的技术路线概括了这一过程：

数据 → 信息 → 知识

文本挖掘与知识发现的核心，就是推动非结构化文本逐步向结构化信息和知识转化；而随着大模型、RAG和GraphRAG等技术的发展，文本挖掘也正在从传统的“模式发现”，进一步走向“知识生成与智能服务”。

这正是我们在大模型时代重新系统梳理文本挖掘与知识发现的原因。

一、大模型不是终点，而是文本挖掘与知识发现的新起点

大语言模型拥有强大的语言理解和生成能力，但真正进入科研和专业场景之后，仍然会遇到领域知识不足、知识更新不及时、结果难以验证以及模型幻觉等问题。

这也是为什么今天的大模型应用越来越重视外部知识。

RAG通过“先检索，再生成”的方式，让模型在回答问题前先访问外部知识库；GraphRAG则进一步把知识图谱中的实体、关系和图结构引入检索与生成过程，让模型不仅能够找到相关文本片段，还能够理解知识之间的关联。

但这里又出现了一些更基础的问题：

高质量知识库从哪里来？领域实体如何识别？实体关系如何抽取？文本如何清洗和组织？知识图谱如何构建？

这些问题最终仍然离不开文本挖掘与知识发现。因此，本书并没有把传统文本挖掘与大模型割裂开来，而是试图呈现一条连续的技术演化路径：

传统文本分析 → 机器学习 → 深度学习 → 语义理解 → 知识发现 → 知识图谱 → 大语言模型 → RAG/GraphRAG → 智能服务

本书中也明确提出，大语言模型能够显著提升语义表征与跨任务泛化能力，而RAG、GraphRAG等技术则可以通过融合外部知识资源和结构化约束，进一步增强复杂知识场景中的领域适配能力、语义理解深度和结果可解释性。

所以，这本书真正想讨论的并不是“传统方法和大模型谁更重要”，而是：

如何把传统文本挖掘、深度学习、知识图谱与大模型重新连接起来，形成完整的知识发现技术体系。

下图详细展示了传统文本挖掘与大模型时代文本挖掘的差异。

二、从0到1：一条贯通“文本—信息—知识—智能”的学习路线

很多初学者最大的困惑，并不是某个算法学不会，而是知识太碎。

今天学中文分词，明天学TF-IDF；接着学文本分类、BERT和命名实体识别；后来又接触知识图谱、RAG和大模型。每项技术似乎都学过，但真正面对一个科研课题或工程项目时，却不知道应该从哪里开始，也不知道这些技术之间有什么关系。

因此，本书没有按照“算法百科全书”的方式组织内容，而是按照“起始—基础—高阶”三个层次搭建完整学习路径。

起始篇重点解决“基础从哪里来”。内容包括Python编程、常用数据分析工具、机器学习、深度学习、概率模型、信息论以及词嵌入和文本表示等。读者不仅要知道算法怎么调用，还要理解文本为什么能够转化为向量、分类模型为什么能够区分文本、注意力机制解决了什么问题，以及Transformer为什么会成为今天大语言模型的重要基础。

基础篇进一步解决“机器如何逐步理解文本”。全书从中文分词、词性标注、命名实体识别等词法分析入手，再进入句法结构、依存关系和语义分析，最后延伸到文本分类、文本聚类和情感分析等典型任务，形成从“词”到“句”，再到“语义”和“应用任务”的完整路径。

高阶篇则重点回答“如何从文本中进一步发现和利用知识”。内容涵盖主题挖掘、主题演化、智能问答、知识图谱、机器翻译以及古文字图像数字化处理等，并进一步把文本分析延伸到多模态信息处理与复杂知识服务场景。

因此，这本书最终希望帮助读者建立的不是若干孤立技能，而是一张完整的技术地图：

文本处理 → 文本表示 → 文本理解 → 文本挖掘 → 知识发现 → 知识组织 → 智能应用

三、从“文本挖掘”到“发现知识”：本书真正想训练的核心能力

传统文本分析往往关注词频、分类、相似度等问题，但知识发现更进一步。例如，面对数万篇论文，我们不仅想知道哪些词出现频率最高，更希望知道：

哪些研究主题正在兴起？哪些主题正在衰退？不同技术方向之间如何发生交叉？一个研究领域十年来经历了怎样的演变？

面对新闻和政策文本，我们不仅想统计关键词，更希望识别其中的人物、机构、地点和事件，并进一步发现它们之间的关系。

面对网络安全威胁情报，我们不仅需要判断文本属于什么类型，还需要识别攻击组织、恶意软件、漏洞、攻击技术和基础设施，并将这些零散信息组织成结构化知识。

这就是从“文本挖掘”走向“发现知识”的过程。

因此，本书不仅介绍文本分类、聚类、情感分析等基础任务，也重点进入主题挖掘、主题演化、知识图谱和智能问答等更高层次内容。其核心目的，就是帮助读者理解：

文本挖掘的终点，不是获得一个统计结果，而是逐步形成可以被组织、关联、检索、利用和推理的知识。

当文本中的实体和关系能够被识别、组织并形成知识网络之后，这些知识就能够进一步服务于搜索、问答、推理以及大模型知识增强。这也正契合本书中提出的“从文本处理到知识服务”的整体技术路径。下图展示了本书中GraphRAG抽取威胁情报实体与关系的效果图。

四、理论、代码与案例并重：不只“看懂”，更要真正“做出来”

一本技术书最容易出现两个极端。

一种是理论很多，读完觉得“懂了”，真正打开电脑却不知道从哪里开始；另一种是代码很多，只能照着运行，却不知道代码为什么这样写，也无法迁移到自己的问题中。

本书希望在两者之间找到平衡。

因此，全书强调“理论 + 方法 + 实践”的结合。一方面系统解释核心概念和关键原理，另一方面使用Python实现典型算法，并结合实际案例帮助读者理解技术如何落地。

本书兼顾基础理论与方法实践，既系统讲解核心概念与关键原理，又深入解析典型方法与应用案例，并进一步拓展至信息抽取、知识图谱构建和多模态分析等前沿应用场景。

我们更希望读者通过本书完成三个层面的能力提升：

第一层是“看懂”——理解文本挖掘与知识发现的原理；
第二层是“做出”——能够利用Python实现典型算法和案例；
第三层是“用好”——能够把这些方法迁移到自己的论文、课题、毕业设计、项目和大模型应用中。

真正有价值的技术学习，从来不只是会调用一个函数，而是能够判断什么时候该用、为什么这样用，以及出了问题应该如何调整。

五、五大核心亮点：为什么这本书值得关注？

从封底可以看到，我们最终把本书特色凝练为五个关键词。

第一，十年AI实践团队倾力打造。 本书不是临时追逐大模型热点，而是作者团队长期从事人工智能、文本挖掘、知识图谱、网络安全、科研教学和项目实践之后形成的一次系统总结。

第二，零基础友好入门。 从Python、基础理论和常用工具讲起，再逐步深入机器学习、深度学习、文本挖掘、知识发现和大模型应用，尽可能降低跨专业读者进入该领域的门槛。

第三，理论与实践双驱动。 不仅告诉你“是什么”，更强调“为什么”和“怎么做”，通过Python、案例和完整技术路线帮助读者真正理解并实现相关方法。

第四，大模型时代全新视角。 在系统梳理传统文本挖掘方法的同时，引入大语言模型、RAG、GraphRAG等技术，让经典方法与前沿技术形成连贯的知识体系。

第五，系统性与可迁移性并重。 本书并不局限于某一种数据或某一个应用，而是希望读者掌握一套可以迁移到科研、教学、工程和交叉学科中的文本智能分析方法。

这些特点最终指向一个共同目标：

让读者获得系统能力，而不是碎片知识。

六、哪些人适合阅读这本书？

本书首先适合正在学习Python、自然语言处理、文本挖掘和人工智能的初学者。如果你已经掌握了一些Python基础，但不知道下一步如何进入NLP、知识图谱和大模型应用，本书可以作为一条较为完整的学习路径。

对于本科生、研究生和高校教师，本书可以作为课程学习、毕业设计、科研训练和论文研究的参考。书中的分类、聚类、情感分析、主题挖掘、实体识别、知识图谱等内容，都可以进一步延伸为具体研究课题。

对于科研人员，本书的方法能够应用于学术论文、政策文本、新闻资讯、网络评论和历史文献等大量非结构化文本，为语料处理、实验设计、知识抽取和知识组织提供方法支持。

对于工程开发人员，则可以沿着“文本处理—模型构建—知识图谱—智能问答—大模型知识增强”的路径，进一步开发文本分类系统、知识图谱系统、领域问答系统和大模型应用。

此外，图书情报、大数据、数字人文、管理科学、网络安全等交叉领域的研究者同样适合阅读。文本挖掘最重要的价值之一，就是它具有很强的方法迁移能力——同一种技术既可以分析论文，也可以分析历史文献；既可以处理用户评论，也可以处理威胁情报。

只要你的研究对象中存在大量文本，这本书中的方法就可能具有价值。

七、一本书出版不是结束，而是持续生长的开始

人工智能技术变化很快，一本技术书不应该在出版的那一刻停止更新。

因此，作者团队将在GitHub持续维护本书配套资源，包括案例数据集、实验代码及后续技术补遗等内容，方便读者进行复现和拓展。

本书还有一个非常重要的观点：

文本挖掘与知识发现技术的核心价值，在于辅助理解、提升效率，而不是代替人的研究与思考。

我们希望读者最终完成的，也不是简单地从“不会使用AI”变成“会调用AI”，而是进一步从“技术使用者”走向“技术驾驭者”，包括对大模型、智能体等新兴技术的应用。

这也是为什么本书一方面介绍大模型，另一方面仍然坚持系统讲解Python、机器学习、深度学习、文本挖掘和知识发现基本原理。

因为工具会变化，模型会更新，但对数据、文本、知识和方法的理解不会轻易过时。

写在最后：真正稀缺的，是从文本中发现知识的能力

回到最开始的问题：

大模型已经这么强，我们为什么还要学习文本挖掘？

因为大模型可以帮助我们阅读文本，却不会自动替我们建立可靠的研究体系；可以生成答案，却不能保证每个答案都准确可信；可以理解语言，却仍然需要高质量数据、领域知识和结构化知识支撑专业应用。

从文本中找到信息，是第一步。

从信息中识别关系，是第二步。

从关系中形成知识，是第三步。

而让这些知识进一步支撑检索、推理、问答和决策，才是我们走向智能服务与智慧社会的重要一步。

这也是《Python文本挖掘和知识发现：大模型时代的新挑战与探索》希望与读者一起完成的一条路线：

从数据到信息，从信息到知识；
从文本理解到知识生成，从数据分析到智能决策；
从经典文本挖掘走向大模型时代的知识发现。

十年磨一剑，一朝汇聚成书。

希望这本书能够成为初学者进入文本智能世界的一块踏板，也能够成为科研人员开展文本分析与知识发现的一本案头参考，更希望它能够帮助正在学习大模型的读者补上“数据、文本与知识”这一层真正重要的基本功。

《Python文本挖掘和知识发现：大模型时代的新挑战与探索》，希望大家多多支持！

也期待未来某一天，你能够利用书中的某个方法完成一篇论文、一个毕业设计、一项科研课题，或者真正解决一个现实中的文本分析问题。

那可能才是一本技术书最好的归宿。

新书信息

书名：《Python文本挖掘和知识发现：大模型时代的新挑战与探索》
出版社：北京航空航天大学出版社
作者：杨秀璋、武帅、党超辉、杜瑞祺、徐香香
关键词：Python、文本挖掘、自然语言处理、机器学习、深度学习、文本分类、文本聚类、情感分析、主题挖掘、知识图谱、智能问答、大语言模型、RAG、GraphRAG

本书配套案例、代码与后续技术补遗将在GitHub持续更新。

最后再次提醒赠书活动：评论区点赞数最高的3位读者，各赠送本书1本。

欢迎大家留言：你最希望利用Python、文本挖掘或大模型解决什么问题？

转眼，已经分享了15年技术博客，本书亦是自己15年分享的总结。也欢迎大家在评论区写下与我相识的故事，或者这些年阅读的感受。写文不易，写书更难，一路走来，感谢太多人的支持，也帮助了一些人，不忘初心，唯有感恩！

一本书的出版，从来不是一个人的独行，而是一群志同道合者共同探索、持续打磨的结果。十年磨一剑，从Python编程、机器学习、文本挖掘与知识图谱，到大语言模型、RAG、GraphRAG与智能体，技术不断演进，但我们始终相信，真正重要的不是追逐热点，而是在实践中沉淀方法、在研究中发现知识。
诚挚感谢创作团队成员一路同行，感谢北京航空航天大学出版社及编辑老师的辛勤付出，感谢各高校、科研团队、行业专家、开源社区和广大读者长期以来的支持与帮助。愿本书不仅帮助读者掌握技术，更能启发大家理解技术、驾驭技术，让人类智慧与机器智能彼此赋能，在大模型时代共同探索更加广阔的知识世界。

(By:Eastmount 2026-08-29 周六写于贵阳)

跳转微信打开

[AI安全论文] (52)NDSS26 Chimera：利用多智能体大模型自动模拟内部威胁和ATT&CK映射

Thu, 27 Aug 2026 06:30:00 +0800

原创 YZX&YXZ 2026-08-27 06:30 贵州

智能体自动模拟生成威胁并映射ATT&CK，希望您喜欢！

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

《娜璋带你读论文》系列主要是督促自己阅读优秀论文及听取学术讲座，并分享给大家，希望您喜欢。由于作者的英文水平和学术能力不高，需要不断提升，所以还请大家批评指正，非常欢迎大家给我留言评论，学术路上期待与您前行，加油。

前一篇博客介绍了基于启发式优化器的入侵检测系统。本文将带来NDSS 2026的一篇论文，该论文提出 Chimera，一个基于多智能体大语言模型的内部威胁自动仿真框架，将企业员工、组织协作、正常业务流程和内部攻击行为统一建模，并生成包含六类日志模态、约250亿条日志的 ChimeraLog 数据集，用于支持内部威胁检测方法的训练、评测和分布偏移研究。注意，由于我们团队还在不断成长和学习中，写得不好的地方还请海涵，未来希望能多读多分享，这些大佬真值得我们学习。fighting！

文章目录

一.摘要
二.研究背景：为什么需要 Chimera？

1.内部威胁检测的核心难点
2.现有内部威胁数据集的四类瓶颈

三.核心思想：不是“生成攻击日志”，而是“模拟一个企业社会”
四.Chimera 方法框架

1.Overview
2.组织画像：将业务语境映射为可执行环境
3.Agent 社会
4.威胁场景仿真
5.记忆机制
6.多模态日志采集：从用户动作到系统痕迹

五.ChimeraLog 数据集
六.实验设计与评价指标

1.评测协议
2.数据真实性
3.行为分布
4.检测难度
5.分布偏移（泛化能力）

七.总结与读后感

原文作者：Jiongchi Yu, Xiaofei Xie, Qiang Hu, Yuhan Ma, Ziming Zhao
原文标题：Chimera: Harnessing Multi-Agent LLMs for Automatic Insider Threat Simulation
作者机构 ：Singapore Management University；Tianjin University；Zhejiang University
原文链接：https://www.ndss-symposium.org/ndss-paper/chimera-harnessing-multi-agent-llms-for-automatic-insider-threat-simulation/
发表期刊：NDSS 2026
笔记作者 ：贵州大学 杨子轩&杨秀璋

一.摘要

内部威胁是一类重大且持续存在的安全风险，但在复杂企业环境中仍然难以检测，因为恶意活动通常隐藏在细微的用户行为之中。尽管基于机器学习的内部威胁检测（Insider Threat Detection, ITD）技术已经显示出良好效果，但其有效性从根本上受到高质量、真实训练数据缺乏的制约。这一挑战源于企业内部数据的高度敏感性，使其很少能够被获取；同时也源于现有数据集的局限性，即公开数据集通常规模较小，而合成数据集往往缺乏充分的泛化能力、丰富的语义上下文和真实的行为模式。

为应对这一挑战，我们提出了 Chimera，一个基于大语言模型（LLM）的多智能体框架，能够自动模拟良性和恶意内部人员活动，并监控多样化企业环境中的综合系统日志。Chimera 将每个智能体建模为具有细粒度角色的个体员工，并结合小组会议、双人交互和自主日程安排，以捕捉真实的组织动态。基于从真实事件中抽象出的 15 类内部攻击类型，我们将 Chimera 部署在三种具有代表性的数据敏感型组织场景中，并构建了一个新的数据集 ChimeraLog，用于支持内部威胁检测方法的开发与评估。

我们通过全面的人工研究和定量分析对 ChimeraLog 进行评估，证明了其多样性和真实性。针对现有内部威胁检测方法的实验表明，这些方法在 ChimeraLog 上的检测性能显著低于在现有内部威胁检测数据集上的表现，说明 ChimeraLog 是一个更具挑战性且更接近真实环境的基准数据集。尽管存在分布偏移，在 ChimeraLog 上训练的内部威胁检测模型仍表现出较强的泛化能力，突出了基于大语言模型的多智能体仿真在推动内部威胁检测研究方面的实际价值。

二.研究背景

1.内部威胁检测的核心难点

内部威胁是企业安全中长期存在且难以检测的问题。与外部攻击者不同，内部人员通常拥有合法账号、熟悉业务流程和系统权限，其恶意行为往往混杂在正常工作活动之中。论文指出，内部威胁可以表现为横向移动、数据外泄、IT破坏、欺诈、窃取活动和权限提升等多种形式，具有合法权限掩护、行为隐蔽、攻击链持续时间长等特点。

论文关注的是日志驱动的内部威胁检测，即通过登录、邮件、网页浏览、文件操作、网络流量和系统调用等日志识别异常行为。现有机器学习方法虽然在内部威胁检测中取得了一定效果，但其性能高度依赖大规模、高质量、细粒度标注的数据集。

2.现有内部威胁数据集的四类瓶颈

论文将内部威胁检测数据集的不足概括为四个方面。

隐私约束：
企业内部日志包含业务、人员和资产信息，难以对外共享。
公开数据不够真实：
典型合成数据集（如 CERT）多由规则和人工脚本产生，语义上下文、角色差异与真实协作过程不足；不少数据集也缺少网络流量、系统调用等系统层日志。
采集与标注成本高：
真实企业每天可产生海量活动，长期采集、标注、脱敏和维护成本很高。
适应性差：
组织软件栈、人员行为和业务流程会变化，导致旧数据上的检测器遇到分布偏移而失效。

因此，论文的核心问题是：能否在不接触真实企业敏感数据的前提下，自动生成既真实、又可标注、还可随组织场景变化而更新的内部威胁日志数据？

三.核心思想：模拟企业

Chimera 的创新点不在于简单让 LLM 编写几条攻击日志，而是构建一个可运行的企业仿真环境。每个员工都由 LLM Agent 表示，具有角色、人格、任务、工具和记忆；多个员工之间可以开会、通信、浏览网页、编辑文件、执行代码；恶意 Agent 则在正常工作流中嵌入攻击行为。

作者认为，一个实用的自动数据生成框架应同时具备四项能力：

根据领域软件、通信协议和组织目标灵活配置场景；
生成符合真实工作节奏的良性员工行为；
让攻击者根据上下文自适应地实施不同内部威胁；
采集完整日志并自动产生准确标签，避免大规模人工标注。

这种思路使生成日志具有更强的组织上下文、时序连续性和跨模态一致性。论文图1展示了自动化内部威胁仿真的总体场景：管理者分派任务，员工 Agent 在 OA 系统、邮件系统、数据库和服务器中执行活动，同时日志系统采集登录、邮件、网页、文件、网络流量和系统调用等痕迹

组织与日志模型：

员工按开发者、分析师、管理员等明确角色运行，受基于角色的访问控制约束。
记录四类应用层日志：登录、邮件、网页浏览、文件操作；以及两类系统层日志：网络流量、系统调用。
每个恶意动作都映射至 MITRE ATT&CK 战术与技术，保证行为和日志之间的可追溯关系。

四.Chimera方法框架

1.Overview

图2和算法1给出了Chimera 的完整工作流，主要包括三个阶段：组织画像、Agent 社会构建和威胁场景仿真。算法 1 进一步形式化为四个环节：组织画像、Agent 社会构建、威胁场景仿真、统一日志采集。

组织画像（Organization Profiling）：
若用户未给出完整配置，LLM 根据组织类型和业务目标补全员工、角色、服务和系统环境。
Agent 社会构建（Agent Society Construction）：
为每位员工建立 Agent bundle，注入职位、人格、账户与工具；为攻击者额外分配攻击目标。
威胁场景仿真（Threat Scenario Simulation）：
以天为单位生成计划，以时隙为单位并行执行；员工在沟通后会更新后续日程，攻击者也会据此调整攻击时机。
统一日志（Unified Logging）：
集中采集日志，关联活动、时间戳和攻击标签。

Chimera 的输入为：

X = (E, R, S, G, T)
E：员工集合；R：员工角色；S：系统环境；G：组织目标；T：仿真时长

输出是应用层和系统层日志，以及其对应的攻击标签与上下文。

2.组织画像：将业务语境映射为可执行环境

组织结构包含员工数量、岗位分配和高层业务目标；系统设置则包含操作系统、邮件服务器、办公协作栈、浏览器等。作者强调，即使是软件版本或系统配置的微小差异，也会改变系统层日志的表现。

Chimera 支持两种模式：

用户指定配置：
用于复现某一领域或组织的具体环境；
LLM 自动生成画像：
当细节缺失时，使用结构化模板补足合理的组织设定。

为控制实验，组织被部署到预配置企业服务的标准化容器中。这样既能保证可复现性，也为后续改变组织环境、研究分布偏移提供了可配置接口。

3.Agent 社会

Chimera 并非由一个 Agent 直接扮演员工，而是为每个员工配置一组协作 Agent：

User Agent：
负责生成和维护工作计划；
Assistant Agent：
调用终端、浏览器、文件操作等工具，将计划转化为环境内的具体活动。

每个 bundle 持有统一的员工画像：姓名、部门、角色、容器 ID 与账户等。攻击员工在此基础上获得攻击目标，但仍须继续完成常规职责，从而让恶意迹象自然地混入正常工作流。

为引入受控的个体差异，作者采用 MBTI 轻量人格描述，影响决策倾向、沟通频率、写作口吻与风险偏好。这里的人格并不是心理测量结论，而是让 Agent 的协作节奏和行为分布不至于完全同质。

4.威胁场景仿真

Chimera 的威胁仿真不是先生成攻击、再补正常日志，而是让所有 Agent 在统一组织目标下推进工作。正常员工生成日计划并执行任务；沟通发生后，后续计划会被动态更新；攻击 Agent 则根据目标员工的日程和上下文选择合适时机嵌入攻击活动。

论文将计划划分为多层次结构：

月计划 → 周计划 → 日计划 → 时隙任务执行

每个时间步中，Agent 根据当前任务、系统状态和历史记忆执行操作。攻击行为在日志采集时自动标注，因此无需事后人工逐条标注。

5.记忆机制

为避免 Agent 每天“失忆”，Chimera 使用长短期混合记忆：

长期记忆：
每位 Agent 在每日结束时生成报告，记录已完成任务、未完成目标和沟通内容；摘要在次日输入，用于延续工作策略。
短期记忆：
保留最近 5 轮交互（日程变更、沟通、工具调用）的滑动窗口。

这种设计的作用是让月度仿真中出现持续项目、迭代讨论和逐步推进的攻击链，而不是每天重复无关的独立行为。

6.多模态日志采集：从用户动作到系统痕迹

论文图3展示了 ChimeraLog 的多模态日志采集过程。日志分为应用层和系统层两类。

层次	日志类型	主要内容
应用层	登录日志	用户、容器、登录/登出时间
应用层	邮件通信	发件人、收件人、主题、正文、附件
应用层	网页浏览	URL、访问时间、网页内容
应用层	文件操作	文件创建、读取、写入、修改内容
系统层	网络流量	pcap 数据包、协议字段、流量痕迹
系统层	系统调用	Sysdig/scap 记录的进程、系统调用和参数

此外，Chimera 还可以记录 Agent 的内部操作，例如工具调用、中间产物、生成代码片段、文档修改和 LLM 回复。这使得日志不仅有外部行为痕迹，还有可追溯的上下文链条。

五.ChimeraLog数据集

论文在三个数据敏感型组织中部署 Chimera。每个场景包含 20 名员工 Agent，连续仿真一个月。这三个场景覆盖了科技、金融、医疗三类高敏感数据环境，对应不同业务流程、访问模式和内部风险。

场景	组织目标	典型内部威胁
Technology Company	开发第三人称射击游戏	源码窃取、IT破坏
Financial Corporation	设计市场中性统计套利基金	交易算法窃取、欺诈、未授权交易
Medical Institution	采集电子健康记录并分析季节性流感趋势	非法访问病历、出售健康信息、破坏医疗系统

ChimeraLog 总计约 250 亿条日志，包括约 200 亿条良性日志和 50 亿条攻击日志。论文中进一步给出了各类日志规模：

日志类型	数量
登录记录	约 0.2 billion
邮件记录	约 0.6 billion
网页浏览记录	约 0.8 billion
文件操作记录	约 0.4 billion
网络数据包	约 4.5 billion
系统日志/系统调用	约 18.2 billion
总计	约 25 billion

数据集使用 5W1H 内部威胁分类框架，从公共案例中抽象 12 类攻击，并加入 3 个混合攻击场景。总体覆盖：

恶意内部人员：IP 窃取与系统/应用破坏；
冒充者：欺诈、IP 窃取与跨内部/外部的凭据滥用；
非故意内部人员：数据泄露、权限控制错误和相关风险；
混合场景：数据外泄与系统接管等持续、多步骤行为。

每个攻击都映射为 MITRE ATT&CK Enterprise TTP（如表3所示）。论文以 IP 窃取为例给出三阶段链条：利用同事或凭据取得访问、通过内部邮件等社会工程谋求高权限、再通过物理介质等方式外传敏感文件。该映射同时指定可观测痕迹和对应数据源（邮件、登录、文件操作、网络流量、系统日志）。

六.实验设计与评价指标

1.评测协议

质量评测：

与 CERT v6.2、TWOS 比较；
每个数据集抽取 100 条应用层日志，覆盖登录、邮件、网页历史和文件操作；
每组样本包含 50 条良性与 50 条攻击日志；
5 位具有至少 5 年安全与 AI 经验的独立专家按 5 分 Likert 量表评估真实性和实用性。

ITD 基线评测：

每个数据集保留 10% 测试集，其余样本按 80:20 划分训练和验证；
以用户-日（user-day）行为特征统一不同数据集；
评估 SVM、Temporal CNN、GCN 与 DS-IID（LSTM + Autoencoder）四种代表性检测方法；
重复 5 次实验并报告均值，采用 Precision、Recall 与 F1-score。

底层模型与实现： 作者在实验中使用 Gemini-2.0-Flash、GPT-4o、DeepSeek V3，并基于 CAMEL 与 OWL 实现 Agent 协作架构。

2.数据真实性

图5 展示了专家真实性评分结果。ChimeraLog 的平均真实性得分为 4.20，TWOS 为 4.25，CERT 为 1.78。专家一致性较高，Krippendorff’s alpha 为 0.87。这说明 ChimeraLog 在可读应用层日志的真实感上接近由真实人类参与生成的 TWOS，而明显优于规则合成的 CERT。

图6给出了三类数据集中邮件通信内容的对比。Chimera 生成的邮件具有明确业务语境、专业沟通语气和连续上下文；CERT 邮件虽然语法可读，但语义浅、上下文弱；TWOS 邮件来自真实交互，但由于脱敏处理，内容较短且碎片化。

3.行为分布

图7 比较了 ChimeraLog、TWOS 和 CERT 的日常良性员工活动分布。ChimeraLog 呈现明显工作日节律，包括早晨启动、午间下降和晚间收敛。相比之下，TWOS 受竞赛环境影响更强，CERT 则呈现较明显的规则化模式。

4.检测难度

Table IV 给出了四种 ITD 方法在 ChimeraLog 三个场景和 CERT 上的检测结果。

可以看出，四种模型在 CERT 上普遍取得很高 F1，但在 ChimeraLog 上明显下降。金融场景尤其困难，说明金融业务中的内部威胁更容易与正常行为混淆。

5.分布偏移（泛化能力）

Table V 展示了跨数据集分布偏移实验。论文发现，当模型从一个数据集迁移到另一个数据集时，性能显著下降。尤其是仅在 CERT 上训练的模型，迁移到 Chimera 场景时往往产生接近 100% 的误报率。

Table VI 比较了不同基础模型生成数据的统计特征。论文发现，GPT-4o 生成的事件更多、通信更丰富，整体质量最好。Gemini 在原子任务首次执行中失败率最高，论文报告其初次失败率为 22.5%，且约 85% 的失败来自错误工具调用或虚构工具名。DeepSeek 则可能出现反复修改文档、工作延续到深夜的非收敛推理循环。

七.总结与读后感

Chimera 提出了一种基于多智能体大语言模型的内部威胁自动仿真框架。其核心思想不是简单生成攻击日志，而是先构建一个包含组织目标、员工角色、人格特征、任务日程、群体会议和工具执行的企业仿真环境，再让恶意内部人员、冒充者或非故意内部人员在正常业务流程中嵌入攻击行为。论文最终构建了 ChimeraLog 数据集，覆盖科技、金融和医疗三类数据敏感组织场景，包含登录、邮件、网页浏览、文件操作、网络流量和系统调用六类日志模态，并基于 15 类真实内部攻击场景生成约 250 亿条带细粒度标签的日志数据。

未来工作：

认知与组织层级真实性
智能体层面的真实性（人格、记忆与动机建模）；组织层级结构（部门、分支机构与跨团队动态协作）。
自动化红队
完全自动化的对抗智能体、自适应多阶段攻击策略演化，例如 APT 攻击。
协同演化防御
集成防御智能体，用于自演化的攻防动态建模；分析员反馈与交互式干预。

本论文值得我们借鉴的地方包括：

（1）多智能体可用于构建“组织级安全仿真环境”
Chimera 将员工建模为具有角色、人格、记忆和工具能力的 Agent，并通过会议、邮件、日程更新和任务执行模拟真实组织协作。这种设计启发我们，在安全和威胁情报领域，不能只模拟单个攻击行为，而应构建“组织目标—业务流程—用户行为—攻击嵌入—日志采集”的完整场景。对于靶场建设、APT溯源、供应链攻击仿真和内部威胁检测，这种多智能体组织仿真模式具有较强借鉴价值。

(2) 多智能体适合生成带上下文的安全与威胁情报数据
Chimera 的攻击行为不是孤立插入，而是与员工日常工作、权限边界、沟通内容和系统操作共同演化，并进一步映射到 MITRE ATT&CK TTP。这个思路可拓展到威胁情报知识图谱构建中：由不同 Agent 扮演攻击者、防御者、情报分析员和业务用户，自动生成攻击链、行为证据、日志痕迹、IOC、TTP 和处置建议，从而形成可解释、可追溯、可标注的安全数据资产。

(3) 实验评估设计和框架图值得参考
论文没有只做单一模型性能比较，而是从数据真实性、行为复杂度、检测难度、跨场景泛化和基础模型影响多个角度进行评估。例如，专家评分用于验证日志真实性，行为熵和序列复杂度用于衡量行为多样性，SVM、CNN、GCN、DS-IID 用于评估检测难度，跨数据集实验用于分析分布偏移，OpenAI、Gemini、DeepSeek 对比用于分析基础模型对数据质量的影响。这个评估框架对安全数据集、威胁情报生成和智能体安全系统研究都很有参考价值。

(4) 未来可拓展方向
后续可以进一步构建攻防共演化的多智能体威胁情报仿真平台和威胁推理。在 Chimera 现有员工 Agent 和攻击 Agent 基础上，引入防御 Agent、SOC 分析员 Agent 和威胁情报 Agent，使系统不仅能生成攻击行为和日志，还能自动完成告警研判、攻击链还原、TTP 标注、处置建议生成和防御策略调整。这样可将多智能体从“内部威胁数据生成”拓展到“攻击—检测—溯源—响应—情报推理”的闭环安全智能体系统。

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

(By:Eastmount 2026-08-27 周四夜于贵阳)

前文推荐：

跳转微信打开

《数字人文技术及运用》课程有感：且教且学且珍惜

Sat, 18 Jul 2026 17:12:00 +0800

原创 Eastmount 2026-07-18 17:12 贵州

课程感受，希望您喜欢！

《数字人文技术及运用》：一门值得慢慢讲下去的课
——品数字人文2班五十份课程作品有感

本文由作者在出差的高铁上完成，简单记录教学过程中的心路历程。授课学生为大一新生，课程旨在普及新文科+新工科的交叉内容，理解“人文”的魂，科学规范的了解和使用数智化技术，从而提升学习兴趣更好地开展学习和实践研究。希望大家多多指正，寓教于乐，且教且珍惜！数字人文1班后发，准备写另一种题材的博客。

文章目录

一、曲终鼓别，江湖再见
二、每一份作品，每一种理解
三、那些让我久久不能平静的文字
四、技术只是桥，桥的两边仍然是人
五、下一次课堂，可以有更多可能
六、这门课，真的值得

一.曲终鼓别，江湖再见

转眼，这个学期的《数字人文技术及运用》结束了。

课停下来以后，才有时间坐在电脑前，一篇篇看同学们交上来的课程论文，也慢慢翻看大家写下的课程建议和感受。看得越多，心里越难平静。原本只是一门八次课的本科通识课程，最后却像一条细细的线，把贵州的山水、村寨、古籍、非遗、红色文化，也把来自五湖四海同学们的家乡记忆和青春感受，轻轻地串在了一起。

一百份作品，一百个选题。有人从一条河出发，有人从一座桥出发，有人从一份古老契约出发，也有人从一碗羊肉粉、一段舞蹈、一首歌、一种文字出发。它们并不宏大，却都很真切。看到这些内容时，我常常会停下来多看一会儿。原来一门课真的可以带着学生走向很多地方：走进村寨，走进古城，走进档案，走进红色文化，也走回自己的家乡。

由于本人的学习和研究经历主要来自计算机、人工智能和网络安全。过去很多年，我习惯面对代码、算法、攻击样本、网络流量和实验数据。程序出错了，可以一步步调试；模型效果不好，可以继续调整参数。可人文不是这样。一个古老的文字为什么被创造，一首歌为什么能在村寨里传唱几百年，一座桥为什么不仅是桥，一个非遗为什么能成为一段中华民族共同的记忆，这些问题往往没有标准答案。

所以，刚开始准备这门课时，我其实很担心。

我知道怎样讲文本挖掘、词云、知识图谱、人工智能和大模型，却不敢说自己真正懂水书、侗族大歌、苗绣、清水江文书和阳明文化。人文素养远远不够，是我一直清楚的短板。我甚至常常害怕，因为自己理解得不够深，把原本厚重的文化讲浅了；也担心过于强调技术，让同学们误以为，做几张图、搭一个数据库、生成几幅图片，就算完成了文化保护。

教书是一件很难装懂的事情。尤其面对大一学生，他们眼睛里的认真，会让人不敢敷衍。我能做的，只是多查一点资料，认真备好每一次课，多读几篇文章，多听听人文学者和非遗传承人的讲述，再把自己熟悉的技术放低一点，试着让它为文化服务，而不是让文化变成技术的装饰。回首，感觉一整个学期都在为这门课程忙碌，都在为这门课程奋斗。

二.每一份作品，每一种理解

这门课最初的设计思路并不复杂：从数字人文概论出发，经过资源采集、资源组织、知识挖掘，再走向数字化开发、文化活化与传承。课堂内容也从古籍保护、阳明心学地理可视化，讲到水书智能识别、侗族大歌、苗族刺绣、清水江文书、中华民族千年诗词、贵州红色生态旅游和非遗数字保护。

我希望同学们不只是知道“数字人文是什么”，还可以继续追问：“数字人文能做什么，又能为谁服务？”

但真正让我觉得这门课值得的，并不是课程框架本身，而是同学们后来写出来的那些作品。

有同学用GIS地图呈现文化遗产和民俗活动的空间分布；有同学从二十份清水江契约中提取卖方、买方、中间人和见证人，试着回答“谁在买卖山林”；有同学研究贵州桥文化，关心的不只是桥的外形，还有掌墨师的口诀、榫卯技艺、祭桥仪式和村寨记忆；有同学写水书文字，讨论字形、文化和水书先生之间的共生关系；也有同学用动作捕捉思考布袋戏、摆手舞和金钱杆的传承。

龙同学的《谁在买卖山林？》把清水江文书中的人物关系转化为网络图，让沉睡在契约中的买方、卖方、中间人与见证人重新“相遇”；卢同学从水书的“形”与“人”出发，让我意识到，数字化保护之前，首先要理解一种文化为什么被创造、为什么被相信。王同学写贵州桥文化，看到的不只是桥梁结构，还有匠人的手艺、村寨的生活和一代代人的记忆。

顾同学把古琴、昆曲与太极元素转化为AI拟人化角色，让非遗以年轻人愿意接近的方式出现；黄同学围绕酉阳摆手舞制作AI图片、视频、诗词、歌曲和词云，真正把课程里的工具用进了作品；徐同学从自己在江口成长的经历出发，写金钱杆的动作、曲目、道具和传承困境，文字里不仅有分析，也有对家乡的牵挂。

司同学从邯郸成语出发，思考如何用文本挖掘和知识图谱把两千多个成语背后的人物、地点与历史故事连起来；杨同学把老王山的夜郎文脉、喀斯特地貌和GIS地图放在一起，让一座山同时拥有地质、历史与乡土的温度；李同学写镇远古城赛龙舟，把历史源流、多民族交融、数字档案、新媒体传播和AI生成图片放在一起。

还有同学写唐诗、宋词、苗绣、蜡染、傩戏、地戏、侗族大歌、苗歌、川剧变脸、油纸伞、陶瓷和古建筑；有人写羊肉粉、酸汤、奶皮子、茶文化和地方酒文化；有人写赤水河、丹霞地貌、温泉、古生物化石和哈尔滨的欧陆风情。

许多题目，是我备课时没有想到的。原来学生的家乡，就是一座很大的文化资料库；他们从小见过的人、听过的歌、走过的桥、吃过的食物，都可能成为数字人文的入口。有时候不得不感慨，你们做得真好！

三.那些让我久久不能平静的文字

某位同学的论文和课程感悟，尤其让我感慨。

她写镇远古城赛龙舟，把历史源流、多民族交融、仪式活动、数字档案、新媒体传播和AI生成图片放在一起。那不只是一篇作业，也是在重新认识自己熟悉的地方。很多时候，我们总觉得文化遗产在很远的地方，在博物馆里，在专家的文章里。其实它也可能就在家门口的一条河上，在端午的一阵鼓声里，在长辈的一段回忆里。

她在课程感悟中说，这门课不是单一的人文课程，也不是单一的AI工具课，更像是中华文化与人工智能的一次结合。她提到阳明文化、侗族大歌、清水江文书，也提到ECharts、易词云和大模型工具。她还写到，自己作为财政专业的学生，在其他讲座中听见老师询问数学专业学生是否使用过ECharts时，竟因为这门课提前接触过而感到庆幸。

读到这里，我很欣慰。课程未必能马上改变什么，但也许会在某一天，让学生面对一个比赛、一项任务或一个陌生问题时，心里多一句：“这个工具我见过，我可以试一试。”或许，这就是上课的价值。

她还记得我在课堂上讲过写博客、做总结的习惯。她说，没有记录，人生中的高光和低落都会随着时间慢慢消失，所以她开始记录英语课的一次发言、羽毛球技巧的一点进步，也记录任务太多时的崩溃。

我看到这段时，心里很暖，也有一点惭愧。

老师在课堂上说出的很多话，自己未必觉得重要，却可能被学生认真地记住。也正因为如此，每一句话都应该尽量真诚。教育有时并不是把一个多么高深的知识讲给学生，而是让一个年轻人开始愿意观察自己、记录自己，愿意把一段混乱的生活慢慢整理清楚。

随风潜入夜，润物细无声。

物理专业的某位同学也给我留下了两页手写信。

他说，最初选课时没有抢到理想课程，是“误打误撞”进入了数字人文课堂。在上课之前，他一直担心自己选得不好，但第一节课结束后，就被课堂氛围和课件折服了。虽然不是文科专业，他却在短短几次课里认识了贵州的特色人文，也学会用AI生成PPT、音乐和视频，还觉得这些知识让自己成为科创小组中不可或缺的一员。

更让我感动的是，他记得课堂上老师分享过的大学四年生活总结博客（链接见下）。宿舍熄灯以后，他又从网上找到那篇文章，认真读了一遍。他说，自己不仅羡慕那些丰富的经历，也敬佩其中的努力，希望身边能有一个人生坐标和榜样，引导自己继续向前。

回忆自己的大学四年得与失 - 写于2014年北京

读到这些话时，我久久没有平静下来。尤其是物理专业这位学生转眼就扎进了他们领域的各种竞赛，每次课后都来问我技术问题，我相信未来你一定能拥有丰富的经历和茁壮成长的，一起前行。

老师以为自己只是在讲一节课，学生却可能从中看见另一种大学生活的可能。另一位同样来自物理专业的学生，却能从一座桥的结构里，看见匠人的手、村寨的记忆和仪式的温度。两个物理专业学生的文字让我明白，专业边界没有想象中那么坚硬。理科生也可以拥有细腻的人文感受，人文学科也可以借助数据与技术获得新的表达。

过去十多年，我一直写技术博客。开始的时候，只是想记录代码、整理知识，也帮助那些和我一样走过弯路的人。后来慢慢发现，写作不只是分享，更是一种自我整理。

课程结束后回头看，李同学说自己也想每学年写一次总结；万同学在熄灯后重新找到那篇博客，认真读完。看到这里，我才明白，记录最朴素的意义，不是为了证明自己多么优秀，而是不让走过的路轻易消失。

四.技术只是桥，桥的两边仍是人

当然，看同学们的论文时，也能看见很多不足。有些文章只是列出了很多技术名词，却没有真正说明如何使用；有些AI图片很漂亮，却缺少对文化细节的核验；有些词云和图表没有交代数据来自哪里；有些论文保留了课程模板、占位符，甚至排版还有待优化。

这些问题不能只怪学生，也提醒我，课程还有很多没讲透的地方。

我可能讲了AI能够生成什么，却还要更多地讲AI不能代替什么；讲了数据可视化的效果，却没有充分强调数据来源和统计口径；讲了文化数字化的技术路线，却还需要提醒大家，历史真实性、文化伦理、知识产权和传承人主体性，比一张“好看的图”更重要。

技术越方便，越要学会克制。

AI可以帮助修复一张老照片，却可能生成一张从未存在过的脸；可以复原一个历史场景，却可能把不同时代的服饰和建筑混在一起；可以生成一段非遗介绍，却无法替代传承人几十年的生命经验。

数字人文不是用技术重新发明文化，而是尽可能尊重地保存、整理、理解和传播文化。

因此，我越来越觉得，这门课不是我单方面教学生。很多时候，是学生的作业反过来提醒我，什么是数字人文，什么是人文。

它不是技术的热闹，也不是人文的标签。它应当是一个人愿意认真面对一份资料、一种技艺和一段记忆，尝试用合适的方法，让它被更多人理解。

技术只是桥，桥的两边仍然是人。

一张清水江文书关系图，最后指向的是那些曾经生活过的人；一幅《红楼梦》的人物图谱，承载的是多少红学爱好者的记忆与挖掘；一幅摆手舞动作图，最后指向的是一代代传承人的身体记忆；一个水书字形数据库，最后指向的是水书先生的生活和经历；一座桥的数字孪生模型，最后保存的也不只是木头和石头，还有村寨里的故事。

五.下一次课堂

同学们也提出了很多课程建议，我都会认真思考未来完善。

以后这门课可以保留论文，也给学生更多选择。喜欢写作的，可以写研究报告；擅长数据的，可以做图表和数字地图；喜欢设计的，可以开发数字文创；愿意拍摄的，可以记录传承人和地方文化；编程能力强的，也可以搭建一个小型数据库或交互网页；还可以增加小组汇报。

未必每个人都要走同一条路。只要作品里有真实的资料、清楚的思路、合适的技术和自己的判断，就应该被认真对待。

也可以尝试邀请非遗传承人、人文学者、博物馆工作人员和技术人员进入课堂，让学生听见不同的声音。这样或许能够弥补我人文积累不足的缺憾，也能让课程不只停留在课件和电脑屏幕里。

我出身于计算机与网络安全，这一点不会改变，也恰恰构成了我理解数字人文的起点。网络安全教会我尊重证据、关注风险、核验来源；计算机训练让我习惯拆解问题、整理数据、构建系统。现在，我想把这些能力慢慢用到文化保护中，同时补上自己欠缺的人文阅读和文化理解。

知之为知之，不知为不知。

也许我不能把每一种文化都讲得很深，但至少可以告诉学生，面对它们时要保持敬畏；也许我不能回答所有问题，但可以和同学们一起查资料、做实践、找答案。

教师不能因为站在讲台上，就假装什么都懂。承认不足并不可怕。怕的是知道自己不够，却不愿意继续学习；怕的是为了让课堂显得热闹，只追逐最新的工具，而忘记课程最终面对的是文化和人。

六.这门课，真的值得

回头看最初那篇课程介绍，我曾写道，希望这门课能连接人文社会科学与计算技术，让中华传统文化、贵州地域文化和非遗在智能时代获得新的表达。为了八节课，我常常用一周时间准备一节PPT，也会提前到教室，担心设备，担心内容，担心讲得太快或太浅。看到同学们认真听课、课后尝试工具时，觉得所有辛苦都值得。

如今课程真正结束，再读这些论文和手写感悟，我比当时更确定：这门课值得。

不是因为每篇作业都成熟，也不是因为所有技术都真正落地，而是因为同学们开始用新的眼光看待自己的家乡和文化。有人第一次认真了解家乡的一项非遗，有人第一次把一张表格变成图，有人第一次阅读学术文献，也有人第一次意识到，自己熟悉的 一条河、一座桥、一碗米粉和一首侗歌，也值得被记录、被研究、被尊重。

课堂能做到这些，已经很珍贵了。

纸上得来终觉浅，绝知此事要躬行。

未来，我还想继续讲这门课，也想把它讲得更好一些。少一些浮在表面的工具介绍，多一些真实资料和实践过程；少一点对技术的“炫耀”，多一点对文化的理解；让学生不仅学会“生成”，也学会思考；不仅能够“展示”，也愿意倾听；不仅关心作品是否漂亮，也关心它是否真实、是否尊重文化。

课程结束了，但同学们留下的那些题目还会继续提醒我。清水江文书里的人物关系，桥上的掌墨口诀，水书先生的口传内容，苗歌里的声部，赛龙舟时的鼓声……它们让我知道，人文并不遥远，它就在我们生活过的地方。

而数字技术，也不应该只是冷冰冰的代码。

当它愿意弯下身来，去保存一段声音、整理一份古老文书、记录一位老人的讲述、标注一座桥的榫卯结构时，它也会有温度。

愿以后每一次走进教室，我仍然保留这份担心。因为担心耽误学生，才会认真备课；因为知道自己不足，才愿意继续学习；因为敬畏文化，才不敢把技术讲得太轻巧。

且教且学，且行且珍惜。Fighting！

—— 秀璋 2026年7月18日

温馨提示：
《数字人文技术及运用》课程PPT已开源，如果需要的读者可填写下表联系作者，同时为更好地提升教学质量，也可以给出课程建议，作者会持续完善课程。祝好，共勉！

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

(By:Eastmount 2026-07-18 周六夜于贵阳)

跳转微信打开

[AI安全论文] (51)ESWA25 基于启发式优化器的入侵检测系统

Mon, 13 Jul 2026 10:57:00 +0800

原创 Eastmount 2026-07-13 10:57 湖南

本文介绍IDS中特征选择和优化算法，希望您喜欢！

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

《娜璋带你读论文》系列主要是督促自己阅读优秀论文及听取学术讲座，并分享给大家，希望您喜欢。由于作者的英文水平和学术能力不高，需要不断提升，所以还请大家批评指正，欢迎大家给我留言评论，学术路上期待与您前行，加油。

前一篇博客介绍了T-trace方法，通过分析日志间的关联性构建事件溯源图。该方法利用张量分解技术精准定位日志社群，并通过计算显著性评分提取事件。通过发现事件社群并基于日志关联构建溯源图，可有效推断APT活动。本文将详细概述基于启发式优化的入侵检测系统，提出一种增强启发式优化算法 EHO，通过动态感知概率、动态搜索空间和基于余弦相似度的种群更新机制，实现更高效、更稳定的特征子集搜索。注意，由于我们团队还在不断成长和学习中，写得不好的地方还请海涵，希望这篇文章对您有所帮助，这些大佬真值得我们学习。fighting！

文章目录

一.研究背景与问题动机
二.主要贡献
三.系统架构与方法流程

1.数据预处理
2.EHO总体框架
3.动态感知概率与动态搜索空间
4.基于余弦相似度的种群更新机制
5.二值映射机制
6.适应度函数
7.GRU分类模块

四.实验设计与结果分析

1.优化函数实验：验证EHO的全局搜索与收敛能力
2.数据集与评价指标
3.特征选择结果：EHO能够以较少特征保持较高性能
4.分类性能比较
5.与已有研究的比较

五.总结与研究启发

原文作者：Hongchen Yu, Wei Zhang, Chunying Kang, Yankun Xue
原文标题：A feature selection algorithm for intrusion detection system based on the enhanced heuristic optimizer
原文链接：https://www.sciencedirect.com/science/article/abs/pii/S0957417424027271
发表期刊：Expert Systems with Applications 2025
笔记作者 ：贵州大学 陈超帆

一.研究背景与问题动机

随着网络基础设施规模的持续扩展以及网络业务类型的日益复杂，网络流量数据呈现出高维化、异构化和噪声化特征。入侵检测系统（Intrusion Detection System, IDS）通常依赖网络流量特征区分正常行为与异常攻击行为，但在实际网络环境中，大量冗余特征、无关特征和噪声特征会显著增加模型训练与测试的计算开销，并可能削弱分类器的检测性能。

因此，如何从高维网络流量中筛选出具有判别能力的关键特征，已成为提升IDS准确率、降低误报率和增强系统实时性的关键问题。论文明确指出，特征选择不仅能够降低模型复杂度，还能够减少冗余信息、提升模型性能并降低过拟合风险，是构建鲁棒IDS的重要预处理环节。

传统特征选择方法主要包括过滤式方法、包裹式方法以及基于元启发式优化的智能搜索方法。

过滤式方法通常计算效率较高，但容易忽视特征之间的组合关系；
包裹式方法能够将分类器性能纳入特征评价过程，但计算成本较高；
元启发式算法则能够在较大搜索空间内寻找较优特征组合，因而逐渐成为IDS特征选择研究中的重要方向。

然而，现有元启发式算法仍普遍存在早熟收敛、易陷入局部最优、搜索策略依赖固定参数以及全局探索与局部开发难以平衡等问题。论文以Crow Search Algorithm（CSA）为基础，针对其感知概率与飞行长度参数难以确定、容易陷入局部最优等不足，提出增强启发式优化算法（Enhanced Heuristic Optimization, EHO），并将其扩展为适用于二值特征选择任务的包裹式特征选择方法。

因此，本文的研究动机可以概括为：在高维、复杂、噪声较多的网络流量环境中，设计一种能够兼顾全局搜索能力、局部寻优能力和特征压缩能力的智能优化算法，从而选择更小且更具判别力的特征子集，并进一步提升IDS的检测精度与运行效率。

二.主要贡献

本文围绕入侵检测系统中“高维特征冗余导致模型性能受限”的核心问题，提出并系统性验证了一种新的特征选择算法——Enhanced Heuristic Optimizer（EHO）。相比传统启发式方法，EHO 在算法结构、动态优化机制、闭环分类反馈以及整体性能上都取得了显著突破。本研究的主要贡献可概括为以下四个方面。

（1）提出了一种面向 IDS 的增强启发式特征选择算法 EHO
本文提出的 EHO 在传统 Crow Search Algorithm（CSA）的基础上进行了结构性创新，引入了更具弹性和自适应能力的动态调节策略，使得特征选择过程能够更有效地跳出局部最优并保持全局搜索能力。具体而言，EHO 的创新包括：

动态感知概率（DP）机制：随迭代过程自适应调节探索（exploration）与开发（exploitation）的比重，使早期搜索更聚焦于全局范围，后期则收敛于关键区域。
动态搜索空间（DS）机制：通过逐步收缩搜索半径，提高搜索精细度，加速算法收敛。
三态更新策略（基于余弦相似度）：利用个体与最优解的相似度动态选择“跟随全局最优”、“跟随历史最优”，或“执行随机扰动”，显著提升算法的稳定性与全局搜索性能。

这种结构性的增强使 EHO 不仅具备更强的灵活性，也在理论上避免了传统启发式算法易早熟、易振荡的不足。

（2）构建了“特征选择 + 深度分类”双层优化框架
传统 IDS 在特征选择阶段与分类阶段往往彼此独立，无法形成性能反馈。本研究提出了新型架构：

特征选择由 EHO 完成，得到候选特征子集
分类性能由轻量级决策树（DT）快速评估，用作 Fitness 值
Fitness 值反向驱动 EHO 的下一轮搜索调整
最终最优特征子集将输入 GRU 深度神经网络进行终态分类

这种结构的优势在于：

特征选择与分类性能紧密耦合，不再依赖固定或静态的评估指标；
DT 提供快速、廉价的反馈信号，显著降低总体计算开销；
GRU 捕获时序流量模式，通常优于传统浅层模型，使特征选择最终优化方向更加贴近实际任务需求。

这一机制使特征选择成为“任务驱动”而非“统计驱动”，具有更强的任务适应性。

（3）提出面向二进制特征选择任务的专用映射机制，提高算法可用性
由于特征选择本质上是 0-1 二值优化问题，传统连续优化算法难以直接应用。本文提出适用于 EHO 的二值映射策略，使连续搜索空间更新后的个体能够有效转换成二值特征选择掩码。该机制使得：

EHO 可以在连续空间进行灵活、高效搜索；
再通过二值映射确保最终解严格符合作为特征选择的约束；
有效避免“连续向量无法落入可行二值空间”的常见问题。

这一设计保证算法既能保持连续优化的优势，又能满足特征选择任务的离散性需求。

（4）在多个基准数据集上验证了 EHO 的优越性与稳定性
本文在三大主流 IDS 数据集上进行了系统实验：

NSL-KDD（41 维特征）
UNSW-NB15（49 维特征）
CIC-IDS2018（80 维特征）

结果显示：

EHO 的特征选择子集维度更小、分类性能更高
在 Accuracy、Precision、Recall、F1-score 上均取得最优结果
EHO 的收敛速度优于 PSO、CSA、HHO（见 Fig. 5）
在复杂、噪声较大的 CIC-IDS2018 上仍能保持 >98% 的分类准确率

这些结果表明 EHO 在实际网络流量数据上具有更强的鲁棒性与泛化性，能够有效适应现代 IDS 的高维场景需求。

三.系统架构与方法流程

本文提出的入侵检测系统并非单纯将启发式算法用于特征筛选，而是构建了一个由“数据预处理—增强启发式特征选择—特征子集评价—GRU分类检测”组成的包裹式特征选择框架。其核心思想是：先通过增强启发式优化算法在高维特征空间中搜索候选特征子集，再利用轻量级分类器对候选特征子集进行快速适应度评估，最终将最优特征子集输入GRU模型完成入侵检测。原文图3给出了该系统的整体架构，主要包括数据预处理、EHO特征选择、特征子集评估和GRU分类四个环节。

1.数据预处理

在系统输入阶段，论文首先对NSL_KDD、UNSW_NB15和CSE-CIC-IDS2018三个数据集进行预处理。预处理主要包括数据清洗、标签编码和归一化三个步骤。

数据清洗用于去除缺失值和重复记录，避免高频重复样本对模型训练产生偏置；
标签编码用于将协议类型、服务类型、连接状态等类别型特征转化为数值形式；
归一化处理则将不同量纲的特征统一映射到[0,1]区间，以降低特征尺度差异对优化搜索和模型收敛的影响。

原文在4.2节明确指出，预处理质量会直接影响后续分类器性能，因此该阶段是EHO特征选择和GRU分类的基础输入保障。

2.EHO总体框架

EHO是本文的核心创新。该算法来源于对Crow Search Algorithm（CSA，乌鸦搜索算法）的改进。CSA通过模拟乌鸦寻找、隐藏和偷取食物的行为实现群体智能搜索，但传统CSA存在感知概率和飞行长度难以设定、搜索过程易陷入局部最优、收敛速度不稳定等问题。为克服这些不足，本文提出Enhanced Heuristic Optimization（EHO），其基本思想如图2 所示：

算法首先初始化种群个体位置，然后计算个体与历史最优位置、全局最优位置之间的相似关系，最后依据相似度和动态参数更新种群位置。图2中的 Xt 表示当前迭代中的个体位置，Mt 表示个体历史最优位置，Gt 表示全局最优位置。

EHO相较CSA的关键改进在于，它不再依赖固定的感知概率和飞行长度，而是引入动态状态函数，使算法在不同迭代阶段自动调节搜索行为。这样做的目的在于：算法早期保持较强的全局探索能力，避免过快收敛；算法后期逐步缩小搜索范围，提高局部开发精度，从而在全局搜索和局部寻优之间形成动态平衡。

3.动态感知概率与动态搜索空间

EHO的第一项核心创新是引入动态感知概率（Dynamic Perception Probability, DP）和动态搜索空间（Dynamic Space Size, DS）。原文将其称为对感知概率和飞行长度的改进。DP用于描述种群在当前迭代中对优化环境变化的感知能力，DS用于控制种群搜索空间的动态变化。随着迭代次数增加，DP和DS按照指数函数自适应变化，使算法能够从大范围探索逐步转向小范围精细搜索。

这一机制的意义在于，它避免了传统启发式算法依赖人工设定固定参数的问题。在特征选择任务中，搜索空间通常随特征维度呈指数级增长，如果算法一开始就过度开发，容易陷入局部最优；如果一直保持大范围探索，又会导致收敛缓慢。EHO通过DP和DS动态调节搜索行为，使算法能够在迭代早期扩大搜索覆盖面，在迭代后期集中搜索潜在优质特征组合，从而提升收敛效率和搜索稳定性。

4.基于余弦相似度的种群更新机制

EHO的第二项核心创新是设计了基于余弦相似度的种群更新机制。原文指出，为进一步提升全局搜索能力和局部开发能力，算法通过动态评估种群个体适应度，并结合局部与全局搜索策略更新个体位置，以避免种群陷入局部最优。具体而言，算法计算当前个体位置与随机选取个体历史最优位置之间的相似度，并据此决定后续更新方向。

这一更新机制可以理解为三类搜索路径的动态切换。

第一类是向历史最优位置靠近，用于利用已有搜索经验；
第二类是向全局最优位置靠近，用于加快向当前最优解收敛；
第三类是在特定条件下执行随机搜索，用于保持种群多样性并跳出局部最优。

与单一的“跟随最优个体”策略相比，该机制更加灵活，既能利用历史搜索经验，又能保留随机扰动带来的探索能力。因此，EHO能够在复杂、多峰的优化空间中保持较好的搜索鲁棒性。

5.二值映射机制

特征选择本质上是一个二值优化问题，即每个特征只有“选择”或“不选择”两种状态。为适应该任务，论文将EHO的连续搜索结果映射为二值特征向量。原文指出，每个候选解被定义为一个长度等于数据集特征数的向量，向量中“1”表示选择对应特征，“0”表示不选择对应特征。由于原始群智能优化算法多用于连续优化问题，论文通过阈值函数将连续个体位置离散化为二值解。图4进一步展示了EHO用于入侵检测特征选择的完整流程。

这一设计保证了EHO既能在连续空间中利用启发式优化算法的搜索优势，又能输出符合特征选择任务约束的离散特征子集。换言之，二值映射机制是EHO从一般优化算法转化为IDS特征选择算法的关键桥梁。

6.适应度函数

EHO采用包裹式特征选择思想，即通过分类器性能评价特征子集优劣。原文4.1节构建的适应度函数同时考虑两个目标：一是所选特征子集对应的分类准确率，二是所选特征数量占总特征数量的比例。其优化目标是：在保证较高检测准确率的前提下，尽可能减少所选特征数量。论文中将准确率项权重设为0.99，将特征数量项权重设为0.01，表明该方法以检测性能为主，同时兼顾特征压缩。

需要注意的是，本文并不是直接用GRU参与每一轮适应度评价，而是使用决策树作为快速评价器。决策树计算成本较低，适合在迭代优化过程中反复评估大量候选特征子集；GRU则用于最终特征子集的分类训练和性能测试。因此，论文方法更准确地说是“EHO + DT适应度评价 + GRU最终分类”的组合框架，而不是“GRU反向驱动DT评价”。

7.GRU分类模块

在EHO搜索得到最优特征子集后，论文将该特征子集输入GRU分类器进行训练和测试。选择GRU的原因在于，GRU作为LSTM的简化变体，具有更新门和重置门，能够在较少参数量下捕获序列数据中的时间依赖关系。网络流量通常具有一定时序行为特征，因此GRU相比普通浅层分类器更适合作为最终检测模型。

表2给出了GRU模型的具体超参数，包括5个隐藏层、batch size为1024、epoch为300、dropout为0.5、学习率为0.0003，并采用NAdam优化器、ReLU激活函数和交叉熵损失函数。

综上，本文方法流程可以概括为：首先对原始网络流量数据进行清洗、编码和归一化；其次初始化EHO种群并基于DP、DS和相似度更新机制搜索候选特征子集；然后通过二值映射得到可用特征掩码，并用决策树和适应度函数评价每个候选子集；最后选择适应度最优的特征子集输入GRU，完成入侵检测分类。该流程的创新性主要体现在三个层面：一是EHO本身的动态优化机制，二是连续搜索到二值特征选择的映射机制，三是“快速适应度评价 + 深度分类验证”的组合式IDS建模思路。

四.实验设计与结果分析

本文实验主要分为两个层面：第一层是标准优化函数实验，用于验证EHO本身的全局搜索能力、收敛速度和鲁棒性；第二层是入侵检测特征选择实验，用于验证EHO在真实网络流量数据上的特征压缩能力和检测性能。

1.优化函数实验：验证EHO的全局搜索与收敛能力

在优化算法验证部分，论文选取Schaffer、Booth、Easom、Branin、Rosenbrock和Rastrigin六类经典测试函数，并在30维优化问题上比较EHO与CSA、CSO、EFA、BWO、RIME、ZOA等算法的表现。表3列出了各测试函数的数学形式、搜索范围和最优值，图5展示了不同算法在六类函数上的收敛曲线。实验中所有算法采用相同设置，即种群规模为60、迭代次数为500、问题维度为30，以保证对比公平性。

从Fig. 5可以看出，EHO在多数测试函数上表现出更快的收敛速度和更好的最终优化值。尤其是在Schaffer、Easom、Branin和Rastrigin等多峰或复杂函数上，EHO能够持续优化并接近全局最优，而部分对比算法在中后期出现停滞或震荡。这说明EHO的动态感知概率、动态搜索空间和相似度驱动更新机制确实增强了算法跳出局部最优的能力。该实验为后续将EHO用于IDS特征选择提供了算法层面的有效性证明。

2.数据集与评价指标

在入侵检测实验中，论文使用NSL_KDD、UNSW_NB15和CSE-CIC-IDS2018三个公开数据集。

NSL_KDD包含41个特征，主要用于验证算法在经典IDS数据集上的有效性；
UNSW_NB15包含49个特征，涵盖多种现代攻击类型；
CSE-CIC-IDS2018包含80个网络流量特征，并覆盖Brute Force、Botnet、DoS、DDoS、Web Attack、Infiltration等多类攻击场景。

表1给出了CSE-CIC-IDS2018中的攻击类型及流量数量分布，说明该数据集规模更大、攻击类型更丰富，也更能反映复杂网络环境下的检测挑战。论文采用Accuracy、Precision、Recall和F1-score作为检测性能评价指标。

3.特征选择结果：EHO能够以较少特征保持较高性能

表4、表5和表6分别展示了不同算法在NSL_KDD、UNSW_NB15和CSE-CIC-IDS2018上的特征选择结果。在NSL_KDD上，EHO仅选择4个特征，即[FR2, FR35, FR36, FR39]，少于CSA的6个、PSO的11个、HHO的7个和GA的7个，体现出较强的特征压缩能力。在UNSW_NB15上，EHO选择5个特征[FR10, FR18, FR19, FR31, FR41]，与HHO数量相同，但少于GA的9个。在CSE-CIC-IDS2018上，EHO选择7个特征[FR0, FR22, FR41, FR55, FR67, FR79, FR80]，少于PSO的20个和CSA的9个，与HHO数量相同，但多于GA的6个。

因此，准确表述应为：EHO总体上能够选择较少且更具判别力的特征子集，并不在每个数据集上都绝对选择最少特征，但其所选特征在后续分类性能上表现更优。这一点很重要，因为特征选择的目标并不是单纯追求特征数量最少，而是在特征压缩和检测性能之间取得最优平衡。

4.分类性能比较

在分类性能方面，表7展示了NSL_KDD数据集上的结果。EHO-GRU取得90.95%的Accuracy、90.94%的Precision、90.95%的Recall和90.94%的F1-score，明显优于未进行特征选择的GRU，以及CSA、PSO、HHO、GA等特征选择方法。

表8展示了UNSW_NB15数据集上的实验结果。EHO-GRU取得93.40%的Accuracy、95.49%的Precision、89.71%的Recall和91.93%的F1-score。相较HHO-GRU的90.57% F1-score和GA-GRU的89.88% F1-score，EHO仍保持领先。值得注意的是，EHO在该数据集上的Precision达到95.49%，说明其能够有效降低误报，即被判定为攻击的样本中真实攻击比例更高。这对于实际IDS部署具有重要意义，因为误报过高会显著增加安全运维人员的告警处置负担。

表9展示了CSE-CIC-IDS2018数据集上的结果。该数据集特征维度更高、攻击类型更多，因而更能检验算法在复杂场景下的鲁棒性。虽然未进行特征选择的GRU在Recall上与EHO非常接近，但EHO在Accuracy、Precision和F1-score上表现更优，并且仅使用7个特征即可达到该性能。相比之下，PSO虽然选择了20个特征，但F1-score为97.71%；GA虽然选择6个特征，但F1-score仅为96.53%。这表明EHO选择的特征子集兼具压缩性和判别性。

从图示结果看，图6、图7、图8和图9分别从Accuracy、Precision、Recall和F1-score四个角度可视化比较不同GRU-based NIDS算法。整体趋势表明，EHO-GRU在三个数据集上均保持较高水平，尤其在Accuracy、Precision和F1-score方面表现稳定。这说明EHO并非只在单一数据集上有效，而是具有较强的跨数据集适应性。

5.与已有研究的比较

表10进一步将GRU-EHO与已有入侵检测方法进行横向比较。这一结果表明，GRU-EHO不仅优于本文内部设置的多种特征选择算法，也在与已有IDS研究的对比中展现出较强竞争力。尤其是在实际应用中，Precision较高意味着误报更少，能够降低安全运营中的告警噪声和人工分析成本。

综上，在优化函数实验中，EHO表现出较快收敛速度和较强全局搜索能力，说明其动态机制能够有效缓解传统启发式算法早熟收敛问题。其次，在特征选择实验中，EHO能够从不同规模的数据集中筛选出较少的关键特征，降低输入维度和模型复杂度。再次，在最终分类性能上，EHO-GRU在Accuracy、Precision、Recall和F1-score等指标上整体优于CSA、PSO、HHO、GA等对比方法，并在多个数据集上保持较好稳定性。

五.总结与研究启发

本文针对IDS中高维特征冗余、噪声干扰和传统优化算法易陷入局部最优等问题，提出增强启发式优化算法EHO，并将其应用于包裹式特征选择任务。EHO通过动态感知概率、动态搜索空间和基于余弦相似度的种群更新机制，改善了传统CSA在参数固定、局部最优和收敛速度方面的不足。结合二值化映射和决策树适应度评价，该算法能够有效搜索适用于IDS的关键特征子集。最终，经过EHO筛选后的特征被输入GRU分类器进行检测，实验结果验证了该方法在特征压缩与检测性能提升方面的有效性。

从研究启发来看，该文表明，在网络安全检测任务中，模型性能不仅取决于分类器本身，也高度依赖输入特征的质量。对于高维网络流量数据而言，合理的特征选择能够降低计算复杂度、减少噪声干扰，并提升分类模型的泛化能力。本文所采用的“智能优化算法 + 包裹式特征选择 + 深度分类器”框架，为IDS性能优化提供了一种较为清晰的技术路径。

不过，本文也存在进一步拓展空间。

首先，EHO虽然在三个公开数据集上取得较好结果，但仍主要基于离线静态数据集评估，尚未充分验证其在真实流式网络环境中的在线适应能力。
其次，论文最终分类器采用GRU，能够一定程度上处理序列依赖，但对于更复杂的长程依赖关系、图结构流量关系或跨主机攻击链建模，仍可进一步引入Transformer、图神经网络或时序图学习方法。
再次，特征选择算法的可解释性仍可深化，例如进一步分析所选特征与不同攻击类型之间的因果关系和安全语义，从而提升算法结果对安全分析人员的可理解性。

总体而言，本文的价值在于从特征工程角度提升IDS性能，而不是单纯依赖更复杂的分类模型。其核心启示是：在入侵检测系统构建中，面向任务目标的高质量特征选择，是提高检测性能、降低计算成本和增强模型鲁棒性的关键环节。

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

(By:Eastmount 2026-07-13 周一夜于贵阳)

前文推荐：

跳转微信打开

[AI安全论文] (50)TDSC23 T-Trace：基于多源系统日志关联的APT溯源图构建

Thu, 09 Jul 2026 15:51:00 +0800

原创 YD 2026-07-09 15:51 中国台湾

本文介绍APT关联溯源图构建方法，希望您喜欢！

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

前一篇博客详细综述了网络威胁狩猎技术，探讨了智能本体与自动化工具的资源整合路径，涵盖了监督与无监督学习、推理机制、图方法及规则方法等多种建模策略，并分析了关键挑战和困难。本文提出了T-trace方法，通过分析日志间的关联性构建事件溯源图。该方法利用张量分解技术精准定位日志社群，并通过计算显著性评分提取事件。通过发现事件社群并基于日志关联构建溯源图，可有效推断APT活动。注意，由于我们团队还在不断成长和学习中，写得不好的地方还请海涵，希望这篇文章对您有所帮助，这些大佬真值得我们学习。fighting！

文章目录

一.摘要
二.引言
三.动机和场景
四.本文框架

1.总体架构
2.事件识别
3.溯源图与攻击链构建

五.实验

1.数据集与实验设置
2.事件识别的性能
3.事件抽象阈值敏感性分析
4.溯源图构建性能
5.攻击社区划分与攻击链提取
6.T-Trace的运行时性能

六.总结与展望

原文作者：Teng Li, et al.
原文标题：T-Trace: Constructing the APTs Provenance Graphs Through Multiple Syslogs Correlation
原文链接：https://ieeexplore.ieee.org/document/10120960
发表期刊：IEEE TDSC（CCF A）2023

一.摘要

高级持续性威胁（APT）采用复杂隐蔽的渗透手段，导致目标系统漏洞频发、暴露风险激增。因此，我们必须主动构建详尽且清晰的APT攻击链，才能有效应对这类威胁。与传统恶意软件或应用威胁不同，APT能够绕过网络安全防护，对组织乃至国家安全造成严重破坏。然而，现有方法难以精准追踪APT，且在识别其复杂未知的恶意活动时面临依赖性爆炸问题。

本文提出并构建了T-trace方法，通过分析日志间的关联性构建事件溯源图。该方法利用张量分解技术精准定位日志社群，并通过计算显著性评分提取事件。通过发现事件社群并基于日志关联构建溯源图，可有效推断APT活动。实验中，我们使用DARPA数据集并启动了四种当前实用的APT（攻击者追踪）方法。与现有方法相比，T-trace在构建溯源图时能有效减少90%的时间成本，同时达到92%的准确率，该方法可实际应用于APT溯源。

二.引言

高级持续性威胁（APT）利用复杂且隐蔽的攻击手段长期渗透系统，造成严重破坏。与传统的恶意软件攻击不同，APT攻击通过精密的手段绕过网络安全防护措施，通常能在系统中长期存在，难以被传统的入侵检测系统（IDS）发现。这种攻击的最大特点是攻击者不断渗透和扩展攻击范围，而传统安全机制难以追踪和防范APT攻击链的全过程。

现有的基于日志的溯源分析方法面临多个挑战。

首先，它们通常依赖于预先定义的攻击模式，无法应对未知的APT攻击。
其次，许多方法只分析单一日志条目的信息，忽视了日志之间的潜在关联，导致无法全面捕捉到攻击事件的上下文信息。
现有的溯源方法往往受到依赖爆炸问题的困扰，生成的攻击溯源图过于复杂，难以有效处理。

为了解决这些问题，T-trace通过张量分解技术分析多源日志之间的相关性，构建攻击溯源图，从而提高APT攻击链的追踪准确性，并显著减少时间成本。

本文贡献可以总结如下：

首先提出一种基于张量分解的显著性评分算法，用于从日志中识别事件，从而弥合低级日志与高级事件理解之间的语义鸿沟。在事件特征提取过程中，我们仅需少量专家知识参与。之后的攻击提取及攻击链构建均可由计算机自动完成。
T-trace技术通过关联多个系统日志，可对APT攻击溯源进行分析，从而揭示未知攻击链。该方法突破了传统基于训练数据集的依赖，相较于基于学习的传统APT追踪方法，标志着重大技术突破。
T-trace技术显著缓解了构建依赖关系溯源图时的依赖爆炸问题，生成的场景图既保持精简又完整保留了关键攻击者活动，为后续主动威胁防御提供有力支撑。
该技术在事件识别方面较前人成果提升38%的准确率，同时将耗时缩短90%。此外，其生成警报事件的精简依赖关系图准确率高达92%。

三.动机和场景

高级持续性威胁（APT）攻击过程如图1所示，展示了攻击者如何逐步渗透目标系统并执行攻击任务。图中的各个步骤代表了APT攻击的不同阶段，具体如下：

(1) 初始侦察（Initial Reconnaissance）：攻击者通过扫描网络和主机，收集目标系统的基本信息，为后续的攻击做准备。
(2) 初始入侵（Initial Compromise）：攻击者通过社交工程手段，诱使目标用户（如Alice）点击恶意链接（如钓鱼链接），成功进入目标系统。
(3) 载荷植入（Establish Foothold）：在成功入侵后，攻击者在目标计算机上植入恶意代码，获得控制权限。
(4) 提升权限（Escalate Privileges）：攻击者通过注入进程等手段，提升权限，伪装成目标用户或管理员，进一步扩大控制范围。
(5) 内部侦察（Internal Reconnaissance）：攻击者在目标系统内进行内部侦察，获取更多信息，如用户名、密码等敏感数据。
(6) 横向移动（Move Laterally）：攻击者开始在网络内其他计算机上进行横向移动，扩大攻击范围。
(7) 持久化（Maintain Presence）：攻击者通过安装木马、后门等手段确保在系统中的长期存在。
(8) 完成任务（Complete Mission）：最终，攻击者完成其攻击任务，如窃取敏感文件或数据等，达成攻击目的。

1.总体架构

图2展示了高级持续性威胁（APT）攻击分析中事件识别、溯源图构建以及攻击链提取的过程，具体分为两个主要部分：事件识别和溯源图与攻击链构建。

2.事件识别

左侧部分展示了从日志数据库中提取日志字段，并通过评分系统对每个字段进行分析。每个日志项会被分配一个得分，形成多个事件。图中展示了两个示例事件（Event 1 和 Event 2）。这些事件可能是由不同的日志字段组成的，如：

Log1: 包含元素如 element1、element2 等，并附带得分；
Log2: 同样包含不同的元素和相应的得分。

这些元素通过与外部攻击行为（如外部远程服务连接、软件打包、暴力破解等）相关联，从而形成有意义的事件。得分帮助系统评估每个元素的重要性，最终识别出事件（如 E1、E2、E3等）。

3.溯源图与攻击链构建

右侧部分展示了如何从识别到的事件构建攻击溯源图和攻击链。整个过程包括几个步骤：

从爆炸到简洁（From explosion to conciseness）：开始时，事件图可能过于复杂，包含大量不相关的信息。需要通过图的优化与简化，使事件图更简洁、精准。
图构建（Graph composition）：通过识别事件之间的关系（如时间序列、相同的攻击目标等），将相关事件联系起来形成图结构。
权重优化（Weight optimization）：为了消除无关的关系，图中的边权重会进行优化。通过优化权重，去除对攻击链分析无关紧要的事件，提升图的清晰度。
社区划分（Community detection）：通过社区检测算法，识别出攻击相关的社区。每个社区代表一组紧密相关的攻击行为或事件。
溯源图（Provenance graph）：通过社区划分后，最终形成攻击的溯源图，揭示了攻击事件的顺序和关联。
攻击链提取（Chain extraction）：从溯源图中提取出完整的攻击链，帮助安全分析人员准确地追溯攻击过程，找出所有相关的攻击步骤和行为。

在第一部分“事件识别”中，系统首先从多种日志源（如系统日志、防火墙日志、网络流量数据）中收集原始数据，并通过正则表达式对日志进行结构化处理。随后，采用张量分解挖掘日志中的隐含相关性，并使用显著性评分算法评估日志元素的重要性，将相关日志聚合为高层的事件。这一步旨在从大量低层次、杂乱无章的日志中抽象出具有语义关联的事件，为后续溯源分析提供更高级的输入。

在第二部分“溯源图与攻击链构建”中，论文首先描述了从事件关系的初步构建开始，由于事件之间存在时间、进程、网络、文件访问等多维关系，初始图结构往往十分庞大且复杂，因此需要进行简化。作者采用权重优化方法，通过逻辑回归为不同类别的事件关系赋予不同权重，从而削弱无关或弱相关的事件连接，解决传统溯源方法中常见的依赖爆炸问题。

接着，系统对加权后的事件图执行社区划分，以识别逻辑相关的事件聚类。为此，论文提出了增强版 Louvain 社区检测算法，通过改进局部移动策略与划分精炼机制，提高社区划分的准确性和稳定性。经过社区划分后，系统得到结构化的溯源图，用以呈现攻击活动的整体脉络。

在最后一步，系统从攻击相关的社区中提取攻击链，通过事件的时间顺序、进程父子关系以及文件访问顺序等信息，构建出攻击行为的完整链条。这使得攻击者从初始入侵到最终目标的各个步骤得以还原，从而完成攻击溯源分析的最终目标。整体而言，APPROACH OVERVIEW 清晰展示了 T-trace 如何从海量日志出发，逐层抽象并构建出清晰、可解释的攻击链路，为APT攻击分析提供了系统化的方法框架。

五.实验

1.数据集与实验设置

论文在实验中主要采用两类数据来源：

一是研究者自行模拟的四类实际APT攻击场景；
二是公开数据集，包括DARPA Transparent Computing数据集和CSE-CIC-IDS2018日志集。

模拟环境中，目标主机采用Windows 7系统，攻击端采用Kali Linux系统，并根据已有攻击报告复现了四类APT攻击。同时，为更接近真实用户场景，实验环境中还加入了网页浏览、聊天等正常用户行为。DARPA数据集来源于2019年5月红队与蓝队对抗演练，包含大量正常事件与攻击事件；CSE-CIC-IDS2018日志集则用于进一步验证T-trace在大规模日志场景下的效率与准确性。

数据集一：https://github.com/darpa-i2o/TransparentComputing
数据集二：https://www.unb.ca/cic/datasets/ids-2018.html

实验设置问题：

Q1. How about the performance of event recognition? (Section VI-B)
Q2. How to determine the threshold in event abstraction? (Section VI-C)
Q3. Compared with other existing community discovery methods, what is the performance of T-trace’s community division? (Section VI-D)
Q4. Based on the attack community obtained after community division, what is the performance of T-trace to construct a complete attack chain? (Section VI-E)
Q5. What is the runtime overhead of T-trace to perform provenance graph construction? (Section VI-F)

2.事件识别的性能

图5展示了在不同参数δ和β取值下，系统从日志中提取出的模板数量变化。实验使用50万条连续的原始网络日志和系统日志，考察模板提取阶段的参数影响。其中，δ表示DBSCAN中的距离阈值，β表示模板词在所有词中的占比。

实验结果表明，δ和β越大，提取出的模板数量整体越多。模板数量过多会降低后续张量分解效率，模板数量过少又会影响事件抽取准确性，甚至导致相邻事件无法区分。综合模板提取能力与后续事件抽取需求，论文最终选择β=0.6、δ=0.01作为后续实验参数。

图6展示了不同迭代次数下，提取出的事件模板占总模板数量的比例。该指标用于衡量LTF张量分解模型表达日志数据和抽取事件的能力。实验同样基于50万条连续原始网络日志和系统日志，先提取约6000个日志模板，再观察不同迭代次数下事件模板覆盖比例的变化。

结果显示，随着迭代次数增加，事件模板占比整体提高，说明模型对事件结构的抽取能力增强。但迭代次数过高会增加时间开销并带来过拟合风险，因此论文认为100次迭代已经能够取得较理想效果，虽然200次和500次结果更高，但综合效率与稳定性，100次更适合作为后续实验设置。

图7展示了T-trace与LTF在不同日志数量和不同事件类型下的准确率对比。Fig.7(a)表明，随着日志数量增加，T-trace的准确率保持较高且相对稳定，而LTF准确率则呈下降趋势；当日志数量约为7000条时，T-trace比LTF高出约38%。Fig.7(b)进一步选取运行示例中的7类攻击阶段事件进行比较，结果显示LTF对日志数量变化较敏感，而T-trace整体稳定性更好。总体来看，T-trace平均准确率约为85%，比LTF高约10%—20%，说明其在多源日志事件识别中具有更好的鲁棒性。

3.事件抽象阈值敏感性分析

图9展示了不同顶点阈值和连接阈值对T-trace事件识别准确率的影响。事件抽象过程中，阈值过低会保留过多冗余事件，使事件粒度过细；阈值过高则可能过滤掉关键攻击事件，使事件粒度过粗。实验结果表明，当顶点阈值设置为0.002、连接阈值设置为1.04×10⁻⁸时，T-trace事件识别准确率达到最高，约为88%。

4.溯源图构建性能

实验在DARPA数据集和四类模拟APT攻击场景下，将T-trace与Enhanced PeerHunter、Walktrap、Spin-glass以及未细化划分的Louvain算法进行比较。评价指标包括准确率AC、误报率FP，并在论文中进一步引入F1-score衡量整体效果。结果表明，T-trace通过优化低连通度社区检测，减少了攻击相关事件与非攻击事件之间的错误连接，使溯源图准确率达到92%，误报率低至0.09%；与未细化的Louvain算法相比，准确率提升约5.5%，误报率降低约50%。

5.攻击社区划分与攻击链提取

攻击社区划分的可视化结果如图10所示，图中红色社区表示攻击相关社区，其他颜色社区表示攻击无关或弱相关社区。该图用于说明T-trace能够从复杂事件关系图中区分出攻击相关事件集合，并为后续攻击链提取提供基础。

在攻击链提取实验中，论文进一步以CVE-2017-11882漏洞攻击为例说明T-trace的攻击链还原能力。攻击者首先通过钓鱼邮件诱导目标用户下载恶意Word文档；用户点击并编辑文档后触发EQNEDT32模块栈溢出，并与C&C服务器192.168.1.5建立反向TCP连接；随后攻击者获得受害主机反向Shell，浏览目录和文件，并通过FTP将目标文件上传至192.168.1.5。该过程说明T-trace不仅能划分攻击社区，还能基于事件顺序、进程关系和文件访问关系恢复较完整的攻击链。

6.T-Trace的运行时性能

该实验使用CSE-CIC-IDS2018攻击日志，比较T-trace与Enhanced PeerHunter在大规模日志条件下的时间开销。结果表明，T-trace在社区检测阶段通过设置剪枝判断，减少节点局部移动和无效移动判断，从而提升计算效率。实验显示，T-trace最高可减少约90%的时间成本，并且随着迭代次数增加，其时间优化优势更加明显。

综合PDF实验结果可以看出，T-trace的优势主要体现在三个方面：

第一，在事件识别阶段，通过张量分解与显著性评分相结合，能够比LTF更稳定地从多源日志中抽取高层事件；
第二，在溯源图构建阶段，通过权重优化和增强Louvain社区检测缓解依赖爆炸问题，使溯源图准确率达到92%、误报率低至0.09%；
第三，在攻击链提取与运行效率方面，T-trace能够从攻击相关社区中还原CVE-2017-11882等攻击链，并在大规模日志场景下显著降低时间成本。

总体而言，实验验证了T-trace在APT溯源图构建、攻击链还原和计算效率方面的有效性。

六.总结与展望

本文围绕APT攻击溯源中“日志语义层次低、攻击链长期隐蔽、事件依赖关系复杂”等问题，提出了T-trace方法。该方法通过分析企业审计日志、系统日志和网络流量数据，将底层日志记录抽象为具有语义含义的高层事件，从而弥合原始日志与安全分析之间的语义鸿沟。在此基础上，T-trace进一步利用日志间的因果关系和时间关系构建APT攻击溯源图，并通过权重优化和社区划分剔除无关依赖，缓解传统溯源图构建中常见的依赖爆炸问题。

实验部分通过四类真实APT攻击场景以及DARPA、CSE-CIC-IDS2018等公开数据集对方法进行验证。结果表明，T-trace在事件识别、溯源图构建和攻击链还原方面均具有较好表现：事件识别准确率较已有方法提升约38%，溯源图构建准确率达到92%，同时最高可降低约90%的时间成本。这说明T-trace不仅能够从海量日志中提取关键攻击事件，还能够较为清晰地还原APT攻击从初始入侵、权限提升、横向移动到最终目标达成的完整过程，为安全分析师提供更具解释性和可操作性的攻击场景全景图。

后续工作中，作者计划在更多平台、系统和数据集上验证T-trace的适用性，并进一步结合溯源结果生成更完善的攻击防御指南。同时，如何从原始日志中更准确地识别网络事件、如何适应更多类型的真实业务环境、如何提升方法在复杂异构系统中的泛化能力，仍是值得继续深入研究的方向。

该论文值得学习包括：
第一，问题提出非常清晰，方法设计与问题一一对应。
论文并不是泛泛讨论APT溯源，而是明确抓住三个核心痛点：低层日志与高层攻击事件之间存在语义鸿沟、多源日志之间缺乏有效关联、溯源图容易出现依赖爆炸。随后，作者分别用事件抽象、日志关联、权重优化和社区划分来回应这些问题，整体逻辑非常完整。

第二，实验设计层次分明，图表与方法模块对应紧密。
论文实验不是只给最终准确率，而是依次验证模板提取、事件识别、阈值选择、溯源图构建、攻击社区划分、攻击链提取和运行效率。每一组实验都对应方法中的一个关键环节，这种“模块—指标—图表—结论”的写法值得学习。

第三，案例分析和可视化表达较强。
论文将APT攻击过程拆解为初始侦察、初始入侵、建立立足点、权限提升、内部侦察、横向移动、保持存在和完成任务等阶段，并结合溯源图和社区划分展示攻击链还原过程。这种将技术方法与真实攻击场景结合的写法，能够增强论文的解释性和说服力，也便于读者理解方法的实际应用价值。

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

(By:Eastmount 2026-07-09 周四夜于贵阳)

前文推荐：

跳转微信打开

[智能体攻防实战] 三.基于精调大模型的网络威胁知识自动抽取与分析（CodeBuddy+千帆）

Fri, 26 Jun 2026 19:51:00 +0800

原创 Eastmount 2026-06-26 19:51 贵州

第3篇文章介绍智能体赋能网络威胁分析，希望您喜欢！

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

随着网络攻击活动呈现组织化、持续化和复杂化趋势，安全公告、威胁情报报告、漏洞通报及攻击行为描述等数据快速增长。传统依赖人工阅读、规则匹配和手工标注的威胁情报分析方法，在处理效率、知识抽取一致性和复杂语义理解等方面面临明显局限。大语言模型凭借较强的语义理解、上下文推理和结构化生成能力，为网络威胁知识自动抽取与智能分析提供了新的技术路径。本文以CodeBuddy为开发与实验工具，结合百度千帆精调大模型，系统介绍基于大模型的网络威胁实体与关系自动抽取实践。

文章首先介绍智能体赋能网络威胁自动分析的整体思路。随后，详细说明百度千帆大模型的服务创建、SFT精调、LoRA训练配置、数据集上传、模型发布与API调用流程。在此基础上，借助CodeBuddy完成本地代码开发与调试，构建少样本提示上下文，并调用精调大模型从MITRE ATT&CK威胁描述中自动识别攻击组织、恶意软件、攻击工具和攻击技术等实体，抽取“使用”等语义关系，最终将结果以JSONL格式保存，为后续威胁知识图谱构建、攻击行为关联分析和安全实战研判提供结构化数据支撑。希望这篇文章对您有帮助，最后感谢学生睿杰在实验调试与内容整理过程中给予的帮助，共勉！

代码开源地址：

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

文章目录

一.智能体赋能的网络威胁自动分析
二.百度千帆大模型调用与配置
三.基于大模型的网络威胁自动抽取
四.Codebuddy赋能知识图谱构建
五.总结与展望

前文赏析：

[智能体攻防实战] 一.大模型赋能网络入侵检测实战探索（CodeBuddy和d.run实现）
[智能体攻防实战] 二.CodeBuddy赋能恶意代码分析与家族分类实践
[智能体攻防实战] 三.基于精调大模型的网络威胁知识自动抽取与分析（CodeBuddy+千帆）

传统安全专栏：

一.智能体赋能的网络威胁自动分析

智能体赋能的网络威胁知识自动抽取与分析，旨在面向安全公告、威胁情报报告、漏洞通报、攻击日志及恶意代码分析结果等多源异构数据，构建集信息采集、语义理解、知识抽取、关联分析与辅助研判于一体的自动化处理机制。通过引入大语言模型、知识图谱、检索增强生成与工具调用能力，智能体可自主完成威胁实体识别、攻击关系抽取、技术战术映射、事件链重构及风险摘要生成，从非结构化数据中提取攻击组织、恶意软件、漏洞、基础设施、受害目标和攻击技战术等核心知识。

(1) 多源网络威胁数据智能采集与预处理
面向安全公告、漏洞通报、威胁情报报告、攻击日志、恶意代码分析结果、开源社区信息及安全厂商报告等多源异构数据，构建由智能体驱动的自动采集与预处理机制。智能体可根据预设任务目标，自主完成数据源发现、内容抓取、格式解析、文本清洗、去重归一和可信度初筛，并将非结构化、半结构化和结构化数据统一转换为标准化输入。该方向重点解决威胁数据来源分散、格式不统一、信息冗余和时效性不足等问题，为后续知识抽取与关联分析提供稳定的数据基础。

(2) 网络威胁实体与关系自动抽取
利用大语言模型、命名实体识别、关系抽取和提示工程等技术，从威胁文本中自动识别攻击组织、恶意软件、漏洞、攻击工具、基础设施、受害目标、攻击时间及攻击技战术等关键实体，并抽取“利用”“控制”“投递”“通信”“攻击”“归属”和“影响”等语义关系。智能体可根据不同情报类型动态选择抽取模板和分析策略，实现从长文本、复杂报告和跨段落描述中提取结构化威胁知识。该方向的核心目标是将原始安全文本转换为可计算、可关联和可验证的威胁知识单元。

(3) 威胁知识规范化、对齐与融合
针对不同来源中实体名称不一致、缩写混用、同名异义和重复描述等问题，构建威胁知识规范化与融合机制。智能体可结合上下文语义、规则库、历史知识图谱及外部安全知识库，对攻击组织、恶意软件、漏洞编号、域名、IP地址和攻击技术进行实体对齐与关系消歧，并对重复知识进行合并。通过引入MITRE ATT&CK、CVE、CAPEC等标准体系，可将抽取结果映射到统一的知识表示框架，形成具有一致语义和标准编码的网络威胁知识库。

(4) 攻击链重构与技战术映射
基于抽取后的实体、关系和时间信息，智能体进一步识别攻击活动之间的先后顺序、因果关系和阶段性特征，自动重构攻击链。通过将行为描述映射至MITRE ATT&CK中的战术、技术和子技术，可实现对初始访问、执行、持久化、权限提升、横向移动、数据窃取和命令控制等关键阶段的识别。该方向能够将零散的威胁线索组织为完整的攻击过程，为分析攻击路径、识别关键节点和判断攻击意图提供依据。

(5) 威胁数据分析与实战辅助研判
在结构化威胁知识基础上，智能体可进一步开展跨事件关联、相似攻击发现、攻击组织归属分析、基础设施聚类和威胁演化分析。通过综合时间、行为、工具、漏洞、网络资产和技战术特征，识别不同安全事件之间的潜在联系，并生成风险摘要、攻击画像和处置建议。该方向可直接服务于安全运营中心中的告警研判、威胁狩猎、攻击溯源、应急响应和防御策略制定，帮助分析人员快速从海量信息中定位高价值线索，提升复杂攻击事件的发现效率和响应能力。

二.百度千帆大模型调用与配置

下面利用百度千帆调用云端大模型实现威胁知识抽取，其具体过程如下所示：

第一步，登录百度千帆（百度智能云），点击“立即体验”。

https://cloud.baidu.com/product-s/qianfan_home

第二步，在模型广场中选择“模型服务”，点击“专属推理服务”。

第三步，在弹出的界面中选择“创建推理服务”。

第四步，在创建的专属推理服务中填写服务名称“Eastmount_CTI”，然后选择模型。

大家既可以选择预制的各类大模型，也可以在“我的模型”中选择自己精调的模型。

第五步，在“模型精调”中点击“创建精调作业”，接着配置精调大模型。

第六步，设置精调作业内容。 大模型精调选项包括：

模型精调方式
基本信息：作业、基础模型、基础模型版本
训练配置：增量训练、训练方法（全量更新、LoRA）、参数配置
数据配置：数据来源、数据格式、选择数据集、混合训练、验证集
资源配置
发布模型

（1）当前选择SFT精调方式和Meta-Llama-3-8B模型

（2）设置训练配置参数

（3）数据配置如下，需要选择本地数据集

本地数据集如下图所示：

数据集展示如下，网络威胁数据集，读者可以从Github下载或自行采集。

（4）资源配置后发布模型

温馨提示：介绍完模型精调和通用数据集构建之后，我们又回到专属推理服务任务，继续后续流程。

（7）从“我的模型”中选择已配置好的微调模型

（8）创建专属推理服务，API地址需要设计一个自定义关键词用来调用API，如“test”

选择定时释放并提交创建。

开通成功如下所示，自此，百度千帆微调大模型创建成功。

三.基于大模型的网络威胁自动抽取

第一步，点击上线刚创建的精调大模型。

第二步，通过编辑器如（VS Code或CodeBuddy）打开本地代码。

CodeBuddy打开界面如下所示，其中“APTtrain-rewrite-short-prompt-response.jsonl”文件为采集的威胁情报数据集，包括：prompt和response。

第三步，修改testLLM.py代码，主要讲API Key替换为自己构建的值。

（1）base_model_path修改为百度平台模型名称（详见上面第8步）

（2）AUTHORIZATION_STRING设置为“安全认证”中的AccessKey值。

复制该Key值到代码文件中，Bearer保留，后面的内容为复制的Key。

AUTHORIZATION_STRING="Bearer bce-v3/ALTAK-eGwh*****ec6"

基于大模型的威胁自动抽取代码如下：

import sys
import requests
from bs4 import BeautifulSoup
import csv
import re
import time
import json
import random
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.neighbors import NearestNeighbors



# ==========================================
# 百度千帆 API 参数：直接写在代码里
# ==========================================


API_URL = "https://qianfan.baidubce.com/v2/chat/completions"


AUTHORIZATION_STRING = "Bearer bce-v3/ALTAK-eGwh****ec6"


MAX_RETRIES = 5
BASE_DELAY = 1.0


HEADERS = {
    "Content-Type": "application/json",
    "Authorization": AUTHORIZATION_STRING
}



# System prompt
LOCAL_SYSTEM_PROMPT = """You are an intelligent assistant specializing in APT (Advanced Persistent Threat) threat intelligence analysis.
Based on the following threat intelligence sentence, identify and extract entities and relationships using only the specified types. 
All outputs must be in English and follow the strict format below.


If entities and relationships are found, output in this format:
Entities:(name, entity type), (name, entity type)...
Relations:(entity1, relation, entity2), (entity1, relation, entity2)...


If only entities are found:
Entities:(name, entity type), (name, entity type)...
Relations:No relevant relations


If nothing found:
No relevant entities or relations identified
"""



class LocalLLMWithKNN:
    def __init__(self, base_model_path, lora_model_path=None, jsonl_path=None, system_prompt=None, top_k=3):
        """
        这里保留原来的类名和参数名。
        但是 base_model_path 不再表示本地模型路径，而是百度在线模型名称。
        lora_model_path 保留参数，但在线 API 不需要使用。
        """


        self.top_k = top_k
        self.system_prompt = LOCAL_SYSTEM_PROMPT


        # 百度在线模型名
        self.model_name = base_model_path


        # 加载JSONL数据构建KNN
        self.example_instructions = []
        self.example_outputs = []


        if jsonl_path:
            self._load_jsonl_data(jsonl_path)
            print(f"Loaded {len(self.example_instructions)} examples from {jsonl_path}")


        # KNN相关初始化
        if self.example_instructions:
            self.vectorizer = TfidfVectorizer()
            self.knn = self._build_knn_model()
            print(f"KNN model built with {len(self.example_instructions)} examples")
        else:
            self.vectorizer = None
            self.knn = None
            print("No examples loaded, KNN will not be used")


        print(f"Using Baidu online model: {self.model_name}")


        if lora_model_path:
            print("Notice: lora_model_path is ignored because Baidu API model is used online.")


    def _load_jsonl_data(self, jsonl_path):
        """从JSONL文件加载示例数据：保持你的原逻辑"""
        try:
            with open(jsonl_path, 'r', encoding='utf-8') as f:
                for line in f:
                    line = line.strip()
                    if not line:
                        continue


                    data = json.loads(line)


                    if 'instruction' in data and 'output' in data:
                        self.example_instructions.append(data['instruction'])
                        self.example_outputs.append(data['output'])


        except Exception as e:
            print(f"Error loading JSONL data from {jsonl_path}: {e}")


    def _build_knn_model(self):
        """构建KNN模型：保持你的原逻辑"""
        if not self.example_instructions:
            return None


        vectors = self.vectorizer.fit_transform(self.example_instructions)
        n_neighbors = min(self.top_k + 1, len(self.example_instructions))


        knn = NearestNeighbors(
            n_neighbors=n_neighbors,
            metric='cosine'
        )


        knn.fit(vectors)
        return knn


    def get_similar_examples(self, input_sentence):
        """获取相似的示例：保持你的原逻辑"""
        if not self.knn or not self.vectorizer or not self.example_instructions:
            return []


        try:
            input_vector = self.vectorizer.transform([input_sentence])
            distances, indices = self.knn.kneighbors(input_vector)


            similar_examples = []


            for j in range(1, min(len(indices[0]), self.top_k + 1)):
                idx = indices[0][j]


                if idx < len(self.example_instructions):
                    similar_examples.append({
                        'instruction': self.example_instructions[idx],
                        'output': self.example_outputs[idx],
                        'distance': distances[0][j]
                    })


            return similar_examples


        except Exception as e:
            print(f"Error getting similar examples: {e}")
            return []


    def call_baidu_api_with_retry(self, user_text):
        """
        调用百度千帆 API，替代原来的本地 self.pipe 推理
        """


        payload = {
            "model": self.model_name,
            "messages": [
                {
                    "role": "system",
                    "content": self.system_prompt
                },
                {
                    "role": "user",
                    "content": user_text
                }
            ],
            "temperature": 0.0,
            "top_p": 1.0
        }


        retries = 0


        while retries < MAX_RETRIES:
            try:
                response = requests.post(
                    API_URL,
                    headers=HEADERS,
                    json=payload,
                    timeout=60
                )


                if response.status_code == 200:
                    return response.json()


                elif response.status_code == 429:
                    wait_time = (2 ** retries) + random.random()
                    print(f"    [!] 触发限速 429，等待 {wait_time:.2f} 秒后进行第 {retries + 1} 次重试...")
                    time.sleep(wait_time)
                    retries += 1


                else:
                    print(f"    [-] API 报错，状态码 {response.status_code}: {response.text}")
                    return None


            except requests.exceptions.RequestException as e:
                wait_time = (2 ** retries) + random.random()
                print(f"    [-] 网络异常: {e}，等待 {wait_time:.2f} 秒后重试...")
                time.sleep(wait_time)
                retries += 1


        print("    [-] 已达到最大重试次数，放弃该条数据。")
        return None


    def generate_response(self, input_sentence):
        """生成响应：保持你的执行逻辑，只把模型调用换成百度 API"""


        # 获取相似示例
        similar_examples = self.get_similar_examples(input_sentence)


        # 构建prompt：保持你的原逻辑
        if similar_examples:
            examples_parts = []


            for i, ex in enumerate(similar_examples, 1):
                examples_parts.append(
                    f"Example {i}:\nInput: {ex['instruction']}\n {ex['output']}"
                )


            examples_text = "\n\n".join(examples_parts)
            userText = "\nExamples:\n" + examples_text + "\n\nInput: " + input_sentence
        else:
            userText = "\n\nInput: " + input_sentence


        try:
            print("\n[Prompt Sent to Baidu API]:")
            print(userText)


            api_result = self.call_baidu_api_with_retry(userText)


            generated_text = ""


            if api_result and "choices" in api_result:
                generated_text = api_result["choices"][0]["message"]["content"].strip()
            else:
                generated_text = "ERROR_OR_SKIPPED"


            print(f"\n[Model Response]:")
            print(generated_text)


            time.sleep(BASE_DELAY)


            return generated_text, similar_examples


        except Exception as e:
            print(f"Error generating response: {e}")
            return f"Error: {e}", []



class MITREExtractor:
    """MITRE数据抽取器"""


    def __init__(self, llm_model=None):
        """初始化MITRE抽取器"""
        self.llm_model = llm_model
        self.items = []


    def _load_items(self, csv_file='groups.csv'):
        """从CSV文件加载项目"""
        items = []


        try:
            with open(csv_file, 'r', encoding='utf-8-sig') as file:
                reader = csv.reader(file)
                next(reader)


                for row in reader:
                    if len(row) >= 2:
                        name = row[0].strip()
                        url = row[1].strip()


                        if name and url:
                            items.append({
                                'name': name,
                                'url': url
                            })


            print(f"Loaded {len(items)} items from {csv_file}")
            self.items = items
            return items


        except Exception as e:
            print(f"Error loading CSV file {csv_file}: {e}")
            return []


    def _save_result_to_jsonl(self, instruction, output, filename='extraction_results.jsonl'):
        """将抽取结果保存到JSONL文件"""
        try:
            data = {
                "instruction": instruction,
                "input": None,
                "output": output
            }


            with open(filename, 'a', encoding='utf-8') as f:
                f.write(json.dumps(data, ensure_ascii=False) + '\n')


            print(f"  [Saved to {filename}]")


        except Exception as e:
            print(f"  [Error saving to JSONL: {e}]")


    def _extract_item(self, item_name, url):
        """抽取单个项目的信息"""
        if not self.llm_model:
            print("Error: LLM model not set. Please set llm_model first.")
            return


        try:
            response = requests.get(url, timeout=30)
            soup = BeautifulSoup(response.text, 'html.parser')


            table = soup.find(
                'table',
                class_='table techniques-used background table-bordered'
            )


            if not table:
                print(f"No techniques table found for {item_name}")
                return


            rows = table.find_all('tr')


            for row_idx, row in enumerate(rows):
                td_elements = row.find_all('td')


                if td_elements:
                    last_td_text = td_elements[-1].get_text(strip=True)
                    cleaned_text = re.sub(r'\[\d+\]', '', last_td_text).strip()


                    if not cleaned_text:
                        continue


                    print(f"\n--- Sentence {row_idx}/{len(rows) - 1} ---")
                    print(f"[Input Sentence]: {cleaned_text[:120]}{'...'iflen(cleaned_text) > 120else''}")


                    # 使用百度在线模型生成回答
                    llm_response, similar_examples = self.llm_model.generate_response(cleaned_text)


                    # 将结果保存到JSONL文件
                    if llm_response and not llm_response.startswith("Error:") and llm_response != "ERROR_OR_SKIPPED":
                        self._save_result_to_jsonl(cleaned_text, llm_response)


                    time.sleep(0.1)


        except Exception as e:
            print(f"Error extracting data from {item_name} ({url}): {e}")


    def extract(self, csv_file='groups.csv'):
        """抽取数据"""
        if not self.llm_model:
            print("Error: LLM model not set. Please set llm_model first.")
            return


        # 从CSV文件加载项目
        self._load_items(csv_file)


        if not self.items:
            print("Error: No items loaded from CSV file.")
            return


        # 抽取每个项目的信息
        for index, item in enumerate(self.items, 1):
            print(f"\n{'=' * 60}")
            print(f"Item {index}/{len(self.items)}: {item['name']}")


            self._extract_item(item['name'], item['url'])


            if index < len(self.items):
                time.sleep(0.5)



def run_extraction(base_model_path, lora_model_path=None, jsonl_path=None):
    """运行MITRE数据抽取流程"""


    # 这里仍然保留原来的调用方式
    # 但是 base_model_path 现在是百度在线模型名称
    llm_model = LocalLLMWithKNN(
        base_model_path=base_model_path,
        lora_model_path=lora_model_path,
        jsonl_path=jsonl_path,
        top_k=3
    )


    # 创建MITRE抽取器，传入LLM模型
    mitre_extractor = MITREExtractor(llm_model)


    # 抽取数据
    mitre_extractor.extract()



def main():
    # 这里不再写本地模型路径，而是写百度平台模型名称
    base_model_path = "百度配置的模型名称"


    # 在线 API 不需要 LoRA 路径，保留变量只是为了不改变原执行逻辑
    lora_model_path = None


    jsonl_path = "APTtest-Final-440.jsonl"


    print(f"Starting extraction")
    print(f"Base model: {base_model_path}")
    print(f"LoRA adapter: {lora_model_path if lora_model_path else'Not used'}")
    print(f"KNN data: {jsonl_path if jsonl_path else'Not used'}")


    run_extraction(base_model_path, lora_model_path, jsonl_path)


    print("\nExtraction complete!")



if __name__ == "__main__":
    main()

第四步，在本地CodeBuddy运行Python代码，成功调用精调大模型实现了对非结构威胁的知识抽取。

Entities: (admin@338actors, Attacker), (LOWBALL, MalwareFamily)
Relations: (admin@338actors, Use, LOWBALL)

其中下面展示APT32抽取的实体和关系信息：

{"instruction": "APT32enumerated administrative users using the commandsnet localgroup administrators.", "input": null, "output": "Entities: (APT32, Attacker), (net, Tool)\nRelations: (APT32, Use, net)"}


{"instruction": "APT32has set up and operated websites to gather information and deliver malware.", "input": null, "output": "Entities: (APT32, Attacker), (information gathering, Technique), (malware delivery, Technique)\nRelations: (APT32, Use, information gathering), (APT32, Use, malware delivery)"}


{"instruction": "APT32has set up Dropbox, Amazon S3, and Google Drive to host malicious downloads.", "input": null, "output": "Entities: (APT32, Attacker), (Dropbox, Tool), (Amazon S3, Tool), (Google Drive, Tool)\nRelations: (APT32, Use, Dropbox), (APT32, Use, Amazon S3), (APT32, Use, Google Drive)"}


{"instruction": "APT32has used JavaScript that communicates over HTTP or HTTPS to attacker controlled domains to download additional frameworks. The group has also used downloaded encrypted payloads over HTTP.", "input": null, "output": "Entities: (APT32, Attacker), (JavaScript, Tool), (HTTP, Technique), (HTTPS, Technique)\nRelations: (APT32, Use, JavaScript), (APT32, Use, HTTP), (APT32, Use, HTTPS)"}

最终其将抽取的知识存储至本地Json文件，为后续知识图谱构建提供支撑。

四.Codebuddy赋能知识图谱构建

PS：由于篇幅和时间问题，该部分内容我们将在下一篇博客中详细概述，希望对您有帮助。

五.总结与展望

本文围绕大模型赋能网络威胁知识自动抽取这一主题，结合CodeBuddy与百度千帆精调大模型，构建了从威胁数据读取、在线模型调用，到实体关系抽取与JSONL结果存储的完整实践流程。实验表明，借助大语言模型的语义理解与结构化生成能力，可以从MITRE ATT&CK等非结构化威胁描述中自动识别攻击组织、恶意软件、攻击工具和攻击技术等关键实体，并抽取实体之间的语义关系。与此同时，CodeBuddy在代码生成、参数配置、接口调试和错误排查等环节发挥了重要辅助作用，有效降低了大模型安全应用的开发门槛，提高了网络威胁知识抽取的自动化程度和实验复现效率。

但从当前实现来看，该方法仍存在一定局限。

首先，抽取结果在较大程度上依赖训练数据质量、提示模板设计及精调模型能力，对于跨句关系、隐含攻击行为和复杂指代仍可能出现实体遗漏、类型混淆及关系误判。
其次，当前KNN检索主要基于TF-IDF文本相似度，难以充分刻画威胁行为之间的深层语义联系。
再次，现阶段抽取结果主要以文本和JSONL形式保存，尚未完成实体规范化、同义名称对齐、重复知识融合及知识可信度验证。
此外，API密钥管理、敏感情报保护、模型幻觉控制和人工复核机制也需要在实际应用中进一步完善。

未来可从以下几个方面持续优化：

一是引入向量嵌入模型和检索增强生成机制，提升相似样本召回质量和复杂威胁语义理解能力；
二是构建覆盖攻击组织、恶意软件、漏洞、基础设施、攻击工具及技战术的统一威胁知识本体，实现抽取结果的规范化表示；
三是结合MITRE ATT&CK、CVE、CAPEC等外部知识库开展实体对齐、关系校验和技战术映射，降低模型幻觉与错误抽取风险；
四是进一步引入多智能体协作机制，使不同智能体分别承担数据采集、知识抽取、结果校验、攻击链重构和风险研判任务；
五是将抽取结果写入图数据库，构建可查询、可追踪和可更新的网络威胁知识图谱，并结合图推理、时间分析和关联挖掘技术，实现攻击组织归属分析、相似攻击发现和攻击路径重构。

总体而言，CodeBuddy与精调大模型的结合，为网络威胁情报的自动处理提供了一条具有较强可操作性和扩展性的技术路径。随着大模型、智能体、知识图谱和安全知识库的进一步融合，网络威胁分析将逐步从单一文本抽取向知识融合、因果推理和自主研判演进，为威胁狩猎、安全运营和应急响应提供更加智能、高效的技术支撑。

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

团队新书推荐（精品留言和宣传赠书）

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

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

▼点击下方，即可购书

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

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

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

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

(By:Eastmount 2026-06-26 周五夜于贵阳)

跳转微信打开

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

Wed, 17 Jun 2026 10:18:00 +0800

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

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

随着恶意代码规模化、家族化与变种化趋势日益显著，传统依赖人工经验与规则的恶意代码分析方法在效率、可扩展性和准确性方面面临严峻挑战。AI 辅助分析正逐渐成为安全研究的重要方向。本文以 CodeBuddy 为核心工具，系统介绍其在恶意代码分析与家族分类中的实践应用。

文章首先回顾传统恶意代码分析的局限性，随后概述 CodeBuddy 的能力特征，并重点围绕动态与静态特征提取、AI 赋能的数据预处理、基于机器学习与深度学习的家族分类方法，以及聚类与可视化分析等关键环节展开详细讨论。通过 AI Coding 与安全分析的深度结合，展示 CodeBuddy 在提升恶意家族分析自动化与智能化水平方面的实际价值。

代码开源地址：

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

恶意代码数据集可以从下面申请下载：

PC端：https://whyisyoung.github.io/BODMAS/
Android端：https://androzoo.uni.lu/

文章目录

一.传统恶意代码分析

1.静态特征
2.动态特征

二.CodeBuddy概述
三.CodeBuddy赋能恶意家族分类

1.动态与静态特征提取
2.AI赋能数据预处理
3.AI赋能基于机器学习的恶意家族分类
4.AI赋能基于深度学习的恶意家族分类
5.AI赋能可视化聚类分析

四.总结

前文赏析：

[智能体攻防实战] 一.大模型赋能网络入侵检测实战探索（CodeBuddy和d.run实现）
[智能体攻防实战] 二.CodeBuddy赋能恶意代码分析与家族分类实践

传统安全专栏：

一.传统恶意代码分析

恶意软件（Malware）或恶意代码分析是网络安全研究中的基础性问题，其核心目标在于刻画程序行为特征、识别潜在威胁并实现家族级别的归类与溯源。传统恶意代码分析方法通常从是否真实执行程序的角度，将特征划分为静态特征与动态特征两大类。二者分别从程序结构与运行行为两个层面描述恶意代码，为后续检测与分类提供依据。

然而，随着恶意代码混淆、加壳、变种生成与对抗技术的不断发展，单纯依赖人工经验和规则驱动的特征提取方式逐渐暴露出效率低、泛化能力弱、特征工程成本高等问题。在此背景下，有必要系统梳理传统静态与动态分析方法的技术路径及其局限性，为引入 AI Coding 与智能化分析方法奠定基础。

1.静态特征

静态特征是指在不真实运行程序的前提下，从二进制文件或中间表示中提取的特征信息。这类特征通常反映程序的结构组成与潜在功能意图，具有分析成本相对可控、不依赖运行环境的优点，但对混淆和对抗技术较为敏感。

常见的静态特征包括：

字节码特征
将二进制文件直接映射为字节序列，是最原始的表示形式，未引入任何语义抽象；
IAT（Import Address Table）表信息
PE 文件结构中的关键组成部分，反映程序在运行时可能调用的外部函数，与功能行为密切相关；
Android 权限声明
通过分析应用请求的权限集合，判断其是否存在权限滥用或潜在恶意意图；
可打印字符特征
将二进制内容转换为 ASCII 字符序列并进行统计分析，用于挖掘硬编码字符串或命令；
反汇编跳转块
基于 IDA 等工具获取的基本块与跳转关系，可构造成序列或图结构特征；
静态 API 调用特征
统计或建模程序中出现的关键系统 API；
恶意代码图像化表示
将二进制映射为图像，从视觉模式角度进行分析。

静态特征提取通常依赖 CAPA、IDA Pro 以及安全厂商提供的静态分析能力。这类方法高度依赖人工规则与经验，特征设计成本较高，且在面对重度混淆、加密或多态变种时，鲁棒性明显不足。

CAPA
– https://github.com/mandiant/capa
IDA Pro
安全厂商沙箱

作者前文博客静态分析恶意软件的提取效果如下图所示：

2.动态特征

动态特征分析通过在真实或仿真环境中执行恶意代码，从运行行为层面捕获程序的实际操作模式。相较于静态分析，动态分析更贴近真实攻击行为，但其分析成本与环境依赖性更高。

典型的动态特征包括：

API 调用序列及调用关系
通过记录程序运行过程中调用的系统 API，刻画其功能行为；
控制流图（CFG）
描述程序执行路径的结构信息，可进一步转换为向量或图表示用于机器学习；
数据流图（DFG）
刻画数据在程序内部的传播与依赖关系，用于分析信息泄露或恶意操作逻辑。

动态特征通常借助 Cuckoo、CAPE 等开源沙箱或安全厂商的专有沙箱环境进行采集。尽管动态分析在语义表达上更为充分，但其易受反沙箱技术影响，执行开销较大，且难以在大规模样本分析中高效应用。

Cuckoo
– https://github.com/cuckoosandbox/cuckoo
CAPE
– https://github.com/kevoreilly/CAPEv2
– https://capev2.readthedocs.io/en/latest/
安全厂商沙箱

作者前文博客CAPE动态分析恶意软件的提取效果如下图所示：

二.CodeBuddy概述

随着大语言模型在代码理解与生成任务中的能力不断增强，AI Coding 逐渐从单点式代码补全工具演进为面向软件工程全过程的智能协同范式。在这一背景下，CodeBuddy 作为腾讯自研的智能编程助手，体现了大模型技术在工程级编程场景中的系统化落地路径。

从概念上看，CodeBuddy 是一类以大语言模型为核心、面向全开发生命周期的 AI Coding 平台。其核心目标在于通过自然语言理解、代码语义建模与上下文感知机制，将开发者的业务意图、设计约束与工程规范转化为可执行的代码结构与工程实现，从而实现“意图驱动编程（Intent-Driven Programming）”。与传统基于规则或局部上下文的代码补全工具不同，CodeBuddy 强调对项目级语义、工程结构与历史演化过程的整体理解，使 AI 能够深度参与到软件开发的多个关键阶段。

在系统形态上，CodeBuddy 通过插件、集成开发环境（IDE）与命令行工具（CLI）三端协同，覆盖本地开发、云端开发与自动化流水线等多种使用场景。这种多形态协同设计，使 AI 能够嵌入编码、调试、重构、测试、部署与运维等不同环节，突破了单一开发工具对编程辅助能力的限制，形成贯穿全流程的一体化智能开发环境。
在技术层面，CodeBuddy 以大语言模型作为认知中枢，结合代码理解、上下文建模与工程知识注入机制，实现对复杂软件项目的语义级建模能力。其工作过程强调对代码库、依赖关系、配置文件与历史修改记录的持续感知，并在此基础上完成自然语言需求与代码语义之间的双向映射，通过推理与生成机制输出符合工程规范的代码、注释、测试用例与重构建议。通过开发者反馈与运行结果的闭环迭代，CodeBuddy 能够不断优化生成质量与工程适配性。
基于上述架构，CodeBuddy 在多个维度上展现出显著优势。首先，其具备良好的全场景适配能力，能够在不同开发环境与工程规模下稳定工作。其次，其功能覆盖从需求理解到代码生成、错误定位与文档生成等多个环节，体现出全栈式智能辅助能力。再次，通过上下文感知与一致性约束，CodeBuddy 能在跨文件、跨模块甚至跨语言的生成过程中保持工程结构与风格的统一性，降低大模型“碎片化生成”带来的风险。最后，CodeBuddy 采用以人为中心的人机协同模式，将开发者从高频、重复和易错的实现细节中解放出来，使其更多聚焦于系统设计与问题抽象。

总体而言，CodeBuddy 代表了 AI Coding 从“局部辅助工具”向“工程级智能协作者”的重要演进方向。其在语义理解深度、工程一致性与开发流程覆盖范围方面的优势，为将 AI Coding 方法引入复杂安全分析任务（如恶意代码特征建模与家族分类）提供了坚实的技术基础。

温馨提示：作者团队近期与人民邮电出版社、腾讯AI团队合作撰写了《CodeBuddy领航：AI辅助编程从入门到精通》新书，希望早日与大家相遇，欢迎大家购买与指正！

三.CodeBuddy赋能恶意家族分类

接下来，我们将利用CodeBuddy进行恶意代码分析与家族分类实践。

1.动态与静态特征提取

首先，假设我们已经通过动态分析和静态分析提取了五个家族恶意软件的动态与静态融合特征，如下图所示。

打开恶意家族class2显示的结果如下图所示，包含8列特征，分别对应序号、家族、md5、战术、技术、tid（ATT&CK序号）、静态API序列、动态API序列。

接下来，我们就将利用AI Coding工具实现自动化的分析。注意，这里我们使用融合特征进行分析，体现特征融合的有效性。

2.AI赋能数据预处理

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

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

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

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

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

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

该工程目录如下：

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

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

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

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")

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

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

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

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

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

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

第三步，大模型经过深度思考理解我们的需求，并自动生成机器学习代码，同时调试和运行代码。

自动生成 random_forest_model.py 文件

第四步，动态显示该代码运行的效果图。下图展示了随机森林模型针对五类数据集的预测结果，测试集准确率达到91.32%，超过90%，整体表现不错。

下面我们来检查代码分析的具体结果与可视化图形。

（1）混淆矩阵

（2）分类结果

（3）随机森林重要特征评估，该分析能进一步挖掘哪些关键特征对恶意家族分类存在影响，下面的序号可以转换为真实的特征及与ATT&CK映射关系，譬如：

（4）实验结果，真实分析中以测试集和验证集为主，训练集通常不作比较

温馨提示：Codebuddy有一个非常强大的上下文关联功能（@按钮），比如关联已生成的随机森林Python文件，我们让其在改代码基础上生成SVM模型，即可利用如下的提示词实现。在大型系统开发中，该功能极其重要。

最后，我们给出完整代码。

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("  模型需要进一步优化")

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 = 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)

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 与智能体的引入不仅将重塑恶意代码分析的技术路径，也为构建高效、智能、可演化的安全分析体系提供了重要发展方向。

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

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

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

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

▼点击下方，即可购书

跳转微信打开

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

Wed, 06 May 2026 19:16:00 +0800

原创 Eastmount 2026-05-06 19:16 贵州

新开设智能体安全专栏，希望您喜欢！

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

代码开源地址：

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

文章目录

一.AI Agent赋能网络安全概述
二.CodeBuddy自动构建机器学习IDS
三.CodeBuddy自动构建深度学习IDS
四.云端d.run运行深度学习入侵检测系统

1.配置d.run平台
2.运行深度学习代码

五.总结及新书推荐

前文赏析：

[智能体攻防实战] 一.大模型赋能网络入侵检测实战探索（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辅助编程应用·架构·交付》，正是承载这套方法的最佳实践指南。

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

▼点击下方，即可购书

为什么首选CodeBuddy？

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

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

(By:Eastmount 2026-05-06 周三写于贵阳)

跳转微信打开

AI红队实战攻防指南来袭

Thu, 30 Apr 2026 14:26:00 +0800

洺熙 2026-04-30 14:26 贵州

AI红队实战攻防开源书籍，希望您喜欢！

本文已获作者同意转发。感谢洺熙老师的无私分享，欢迎大家关注他的 Ai沉思录公众号，与师傅认识多年，也在贵阳一起畅聊过，非常厉害的大佬。希望大家能在AI快速发展的今天乘风破浪，真的学无止境，加油！

背景：某加密社区流出一本关于AI安全的材料，浏览阅读见其体系化，适合新入门AI安全领域者借鉴，便借用AI对此进行整理设计

本文导览：解读书籍，共享诸君

书籍链接：

通过网盘分享的文件：AI red实战指南

链接: https://pan.baidu.com/s/1_KDmEIex1jJxcZDWgbe3eQ?pwd=x2e8 提取码: x2e8

主要讲述什么问题

传统安全测试方法论覆盖不了 AI 系统。

资产不在服务器上，而在模型行为边界
漏洞扫描器发现不了 MCP 权限绕过
代码审计工具标记不出提示词模板中的注入点

这本书提供的是新地图：把看不见的资产变成可测绘的攻击面。

内容结构：三层递进

层次	章节	核心问题
基础层	1-2 章	AI 系统怎么搭起来？怎么侦察？
攻击面	3-7 章	每一层可能出什么安全问题？
方法论	8-11 章	怎么组织测试？怎么报告？

攻击面覆盖

Agent 层

直接 / 间接提示词注入
记忆投毒（跨会话持久化）

协作层

A2A 代理网络：流氓代理注册、Agent Card 欺骗

知识层

RAG 管道：摄入投毒、信息提取
Embedding 反演攻击

工具层

MCP 工具链：描述投毒、权限边界探测

基础设施层

供应链、云配置、容器编排漏洞

方法论框架

MITRE ATLAS

在 ATT&CK 基础上增加 AI 专属战术阶段
提供结构化测试检查清单
为漏洞报告提供标准化分类语言

AI 红队生命周期准备 → 侦察 → 攻击面映射 → 漏洞验证 → 报告

每个阶段都针对 AI 系统特性做了调整，可直接作为企业测试流程模板。

防御手法

每种攻击都配有对应的缓解思路：

攻击	缓解方向
记忆投毒	记忆隔离、输入消毒、完整性校验
MCP 权限滥用	签名验证、沙箱隔离、最小权限原则
RAG 污染	知识库来源校验、输出一致性监控

目的不是培养攻击者，而是让安全测试人员能系统识别和验证风险。

适合谁读

适合

有传统渗透/代码审计经验，正接触 AI 产品的安全从业者
需要为 AI 产品线设计安全测试流程的安全架构师
希望建立系统化认知的技术研究人员

不适合

完全无安全基础的读者（不会解释什么是 SQL 注入）
寻找现成工具或一键扫描方案的人
只需要概念了解、不需要动手测试的管理层

书籍优缺点评价

维度	具体表现	技术
定位虚高	大量内容（第 9、11 章）是传统内网渗透/AD 攻击的 AI 换皮	真正 AI 专属的深度技术（对抗样本数学原理、侧信道模型提取）缺失或浅尝辄止
场景过于实验室化	响应头自曝全栈信息、健康检查端点暴露完整配置	现实高价值目标极少如此配合，易产生AI 系统很好摸底的错觉
协议层知识折旧快	MCP、A2A 章节依赖当前协议版本细节	协议一旦做安全性的 breaking change，书中复现命令直接失效
部分攻击链过长	RAG 投毒、Embedding 反演需多步衰减才能形成业务影响	实际红队中投入产出比低于直接的凭据窃取或供应链攻击
时效性风险	AI 安全热点每 6 个月换一茬	预计半衰期 12–16个月，协议与工具链章节会率先过期

结论

如果你面对一个接入 LLM 的新产品，不知道从哪里开始做安全评估——这本书是一个扎实的起点。

它不承诺让你成为 AI 红队专家，但能帮你跨越从完全不懂到知道该测什么、怎么测、用什么语言描述发现的初始门槛。

在这个快速形成的新职业空间里，系统化认知框架比零散技巧更有长期价值

附：阅读路径建议

读者类型	优先章节
完全新手	第 1-2 章（建立 Mental Model）
有概念但缺系统思路	第 3-5 章（攻击面 + 方法论）
安全团队负责人	第 1 章 + 第 5 章 + 第 10 章（战略 + 流程）

跳转微信打开

第一本CodeBuddy书上市了，强烈推荐！

Fri, 24 Apr 2026 21:22:00 +0800

异步图书 2026-04-24 21:22 海南

AI赋能编程新书，干货满满！

关注我们丨文末赠书

“在腾讯内部，AI辅助编程早已不是选择题，而是自下而上形成的共识：从基层程序员到管理层，所有人共同见证着这场效率革命——代码质量稳步提升的同时，程序员单日产能从150行跃升至1500行以上，10倍增长的背后，是编程模式的根本性重塑。”

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

▼点击下方，即可购书

接下来，就让我们跟随本书，一同踏上从“理解 AI Coding理念”到“独立完成复杂系统开发”的完整学习路径。

Part.1

理解AI Coding理念，人机协同，而非替代

《CodeBuddy领航：AI辅助编程应用·架构·交付》首先明确“AI辅助”的核心定位：并非替代开发者，而是增强开发者能力。

AI Coding帮助我们快速实现原型、减少重复劳动、拓宽技术视野，从而让我们更专注于架构设计、问题抽象与创新性思考——这些才是人类开发者不可替代的核心价值。本书的实践设计也处处体现这一理念，引导读者学会与AI工具协同工作，而非被动依赖。

本书开篇梳理人工智能的发展历程：

首先，从符号主义、统计学习到深度学习，重点分析大语言模型的演进及其在编程领域的应用；

其次，通过对比AI编程与传统编程在驱动方式、核心角色、开发效率等多方面的差异，强调AI编程以自然语言意图驱动，通过人机协同提升开发效率、降低技术门槛；

最后，介绍CodeBuddy的技术架构与优势，展现AI Coding从“辅助工具”向“工程级智能协作者”演进的重要方向。

本书提出，AI Coding通过学习大规模代码与文本语料，建立自然语言需求与程序结构之间的语义映射，使编程活动从以语法为中心的“指令式实现”，转向以意图为导向的“语义驱动构建”，在显著提升开发效率的同时，降低技术门槛，推动软件工程向智能化、自动化和协同化方向发展。

AI Coding在提升开发效率、降低技术门槛与增强代码质量方面优势显著：一方面，可快速生成样板代码、接口逻辑与测试用例，减少重复劳动；

另一方面，可通过语义分析发现潜在缺陷并提出重构建议。在应用层面，AI Coding已广泛覆盖Web系统开发、数据分析、科研原型构建与教学辅助等场景。在复杂系统中，AI Coding进一步支持快速迭代与跨角色协作，推动软件开发模式向智能化与平台化方向演进。

本书尚未面世便备受瞩目，关键在于其以CodeBuddy为核心实践载体。CodeBuddy是腾讯自研的、覆盖全栈开发生命周期的智能编程助手，通过插件、独立 IDE和命令行（CLI）工具（CodeBuddy Code）三种形态，为从需求到部署的各个环节提供AI辅助。

那么，为什么首选CodeBuddy？

其一，CodeBuddy以“产品—设计—研发”一体化协作为核心理念，将大语言模型深度融入需求表达、界面设计、代码生成与云端部署全流程，真正实现自然语言驱动开发，让创意快速落地；

其二，CodeBuddy支持一键对接腾讯云CloudBase、Supabase等服务，便于项目构建与部署；

其三，CodeBuddy依托腾讯在AI与开发者生态方面的积累，结合MCP、多智能体等前沿能力，不仅支持高效应用开发，更具备构建复杂智能系统的潜力。

Part.2

掌握实战方法，从入门到精通，

独立完成复杂系统开发

本书并未停留在概念层面的空泛论述，而是循着学习者熟悉的认知路径，从理念、工具、方法到实战、系统与生态，层层递进，步步为营。

入门级读者可从第4章的网页开发入手，跟着案例用CodeBuddy生成在线简历、MBTI测试页面，快速掌握HTML、CSS、JavaScript的应用及CodeBuddy的提示词设计方法；

有基础的开发者可深入大数据分析、新媒体营销网页开发等场景，借助CodeBuddy的自动化能力，搞定数据清洗、可视化、UI生成等烦琐工作，提升开发效率；

进阶学习者则可挑战桌面应用、音乐播放器、微信小程序开发，甚至知识图谱、多智能体系统的构建，感受AI Coding从“代码生成工具”向“智能系统构建平台”的进阶魅力。

更贴心的是，本书对初学者极其友好：概念解释通俗易懂，不故作高深；每个实战项目都有详细的步骤指引，从CodeBuddy的安装部署、环境配置，到项目初始化、代码生成、调试优化，全程手把手教学，哪怕是零基础也能快速上手，真正实现“看完就会，会了就用”。

▲书中提供详细步骤

Part.3

这本书，适合每一个想赶上AI编程浪潮的人

本书适合所有对AI编程感兴趣的读者阅读：

高等院校计算机、信息管理、人工智能、数字媒体等专业的学生，可用于课程项目、科研原型设计与学科竞赛准备；

高校教师、职业教育讲师、科研人员，可用于教学案例转化；

软件开发与工程技术、数据分析与智能应用、新媒体与数字营销等相关岗位的从业人员，可用于构建系统、提升开发与智能分析效率、支持“AI+内容”创作及数据看板搭建。

本书凭借扎实的内容与极强的实用性，获得了多位行业专家的一致推荐。

正如微软全球最有价值专家桂素伟所言：

“未来真正稀缺的能力，不是‘能不能写代码’，而是‘能不能提出好问题、设计好系统、做出正确判断’，以及创造性思维、领导力这类 AI 难以替代的软技能。这些能力，恰恰需要通过大量真实、完整、跨领域的实践来培养。本书所覆盖的项目广度与复杂度，正好为读者提供了锤炼核心能力的训练场。”

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

—END—

原创

初审：刘鑫

复审：栾传龙

终审：孙英

跳转微信打开

[技术分享] 从星辰智能体到AstronClaw：校园场景下的 AI Agent 与智能编程实践

Thu, 23 Apr 2026 06:31:00 +0800

原创 Eastmount 2026-04-23 06:31 贵州

智能体赋能编程与科研基础文章，希望您喜欢！

感谢科大讯飞的邀请，非常荣幸能参与“讯飞AstronClaw全球行”活动。从星火大模型到iFlycode，从星辰智能体到Astronclaw和Astronskill，讯飞在AI点亮世界的路上越走越远，远走远深。作为技术分享者与学习者，也希望能贡献一丝力量，且行且珍惜！

随着大模型技术的持续突破，人工智能正在从“内容生成”阶段迈向“任务执行”阶段，AI Agent逐渐成为新的技术范式。本次分享以“校园场景下的AI Agent与智能编程实践”为主题，系统梳理了智能体（Agent）、OpenClaw、AstronClaw 及其在科研与编程中的实践路径。

AI Agent通过引入任务规划、工具调用与执行机制，将模型能力转化为实际生产力，使AI从“辅助工具”升级为“智能执行者”。在校园场景中，编程教学、科研实验以及论文写作等任务具有明显的流程性与重复性，智能体的引入可以显著提升效率并降低门槛。本文将结合AstronClaw与scientific-agent-skills的实践案例，展示智能体在编程与科研中的真实应用价值。

本文主要涉及以下六个方面内容：

01.智能体基本概念与核心技术组件
02.星辰智能体简介与基本用法
03.从OpenClaw到AstronClaw
04.AstronClaw的基本用法与入门案例
05.Skill驱动的AstronClaw科研实战
06.智能编程实践案例分析

欢迎更多朋友加入到“讯飞AstronClaw全球行”项目中，也推荐大家去使用讯飞的AI产品！

引言

在大模型技术从“能说会道”迈向“动手能干”的演进浪潮中，智能体正成为连接AI认知能力与现实执行场景的关键桥梁。2025年以来，随着GPT-4、星火大模型等基础模型的持续突破，以AutoGPT、BabyAGI为代表的开源智能体框架迅速兴起，标志着大模型从“生成回答”向“自主执行”的范式跃迁正式到来。

与此同时，科大讯飞推出的星辰智能体开发平台，依托星火大模型能力底座，将提示词构建、工作流编排、MCP协议集成与多模型兼容等核心能力整合为全栈式智能体开发环境，极大地降低了智能体应用的开发门槛。在此基础上，AstronClaw作为面向云端托管与企业协同的智能体服务形态，融合了跨渠道接入、Skill技能生态与沙箱安全运行机制，为校园教学、科研编程和日常办公提供了开箱即用的AI助手解决方案。

本文将系统梳理智能体的发展脉络与核心技术组件，深入解析星辰智能体平台与AstronClaw的功能体系，并通过科研实战案例展示如何借助Skill驱动的智能编程模式提升教学与研究效率，以期为高校师生和AI开发者提供一份系统性的实践参考。

在介绍具体内容之前，作者先介绍了自己在科大讯飞“AI大学堂”开源的两门课程，感兴趣的同学可以去AI大学堂学习。

《AI Coding入门到实战》
《星辰智能体入门与开发实践》

一.智能体基本概念与核心技术组件

1.AI Agent发展史

人工智能的概念诞生于1956年的达特茅斯会议，至今已走过近七十年历程。从早期感知机提出、反向传播算法系统化，到IBM Deep Blue击败国际象棋冠军，再到2016年AlphaGo战胜李世石——每一次技术突破都将AI推向新的高度。2017年Transformer架构的问世为后续大模型爆发奠定了底层基础，2020年GPT-3发布标志着大模型时代正式成形。2023年AutoGPT和BabyAGI开启了多智能体协作探索，而2025年至2026年间，以OpenClaw、Manus、星辰智能体为代表的产品化智能体进入落地期，AI真正具备了“会推理、会操作、会执行”的综合能力。

2.智能体是什么？

智能体是指能够在特定环境中感知外界信息、理解任务目标、进行自主规划与推理，并调用工具或执行动作以完成既定目标的智能系统。与传统被动响应的软件程序不同，智能体具备目标驱动、自主决策、持续交互以及环境自适应等核心特征。智能体应用的基本流程如下：

3.智能体的核心要素

智能体的核心运行要素包括感知、规划、记忆、行动与推理五大模块。

感知负责通过用户输入、系统接口获取多模态信息并完成语义理解与结构化表征；
规划则将复杂问题分解为可执行的子任务，确定任务间的依赖关系与执行顺序；
记忆通过向量数据库或知识图谱构建短期和长期存储，实现历史经验与领域知识的保存与检索；
行动将内部推理与决策结果转化为对外部环境的实际作用；
推理则综合运用链式推理（CoT）、反应式推理（ReAct）等策略生成行动方案。五者协同构成了智能体从“听懂需求”到“完成任务”的完整闭环。

4.MCP协议的基本定义

提到智能体，不得不提两个基本概念——MCP和Skill。如果说多智能体系统是一座城市，那么通信协议就是连接各个街区的道路与交通规则。MCP（模型上下文协议）正是这样一套为AI智能体量身定制的“交通系统”。

通过MCP协议，智能体可以无缝调用各种外部工具和服务，实现跨系统的协同工作，为构建复杂、开放、可扩展的智能体生态提供了底层技术支撑。

5.Skill的基本定义

Skill是智能体系统中对特定能力、工具接口或任务流程进行模块化封装的功能单元，本质上是一种可被调用、复用与编排的能力组件。它将外部服务、操作逻辑或领域功能以标准化形式接入智能体，使其由单纯的语言生成系统扩展为具备任务执行能力的行动系统。如果说MCP为智能体提供了“手”来操作工具，那么Skills就是那本“操作手册”。

6.大模型-智能体-MCP-Skill逻辑关系

大模型、智能体、MCP与Skill四者构成了“能力底座—系统形态—连接规范—执行单元”的层级关系与功能分工。四者协同，共同构成了一套完整的智能体应用体系。

大模型提供语言理解与生成的认知基础，是整个体系的“大脑”；
智能体在大模型之上构建目标驱动的任务执行系统，是体系的核心“躯干”；
MCP作为连接模型与外部资源的标准化协议，打通了智能体与外界的“神经通路”；
Skill则是指导智能体执行具体任务的流程与标准，形成了端到端的自主工作流。

7.智能体实战应用场景

智能体的应用场景正在快速拓展。在企业领域，智能体广泛应用于AI客服、行业资讯、电商导购、数据分析、财务报销等业务流程，通过工作流编排实现复杂任务的自动化处理。在校园场景下，智能体则赋能代码教学、科研辅助、论文阅读、简历生成、课程答疑等场景。例如，教师可以利用智能体快速生成教学示例代码，学生可以通过智能体辅助完成科研任务和项目开发。智能体的引入正在重塑校园的教学与科研模式，使AI真正成为师生身边的智能助手。

二.星辰智能体简介与基本用法

1.什么是星辰智能体？

星辰智能体是依托科大讯飞星火大模型能力底座，面向智能体构建、任务编排与工程化落地而形成的应用开发体系。从功能定位看，讯飞星辰Agent开发平台面向IT从业者与AI开发者，提供贯通学习提效、功能开发、工程化落地与企业应用的全栈式Agent开发环境，支持提示词式、工作流式与自主Agent等多种构建方式，并兼容星火、DeepSeek、Qwen、Stable Diffusion等多源模型。

官方平台为：https://agent.xfyun.cn

2.星辰智能体的核心技术架构

星辰智能体平台的核心技术架构包括四大支柱，提供两种主要的创建方式。

3.星辰Agent平台探索

讯飞星辰Agent开发平台为开发者提供了丰富的探索空间。平台支持通过指令Prompt、外部工具、工作流编排和知识库引用构建丰富的智能体应用，构建完成的智能体可以发布至讯飞星火App或配置微信公众号，公开给海量用户使用，也支持一键发布为API，满足业务在不同应用场景下的灵活集成与定制化需求。平台还整合了丰富的模型、插件与MCP Server，支持一站式效果测评，助力开发者快速搭建生产级智能体。

4.快速构建工作流智能体

构建工作流智能体共分六步：第一步，进入星辰Agent平台首页，点击左侧创建按钮，选择工作流创建方式；第二步，选择自定义创建，在空白画布中按需求搭建工作流。

节点是构成工作流的基本元素，画布上默认添加开始节点和结束节点，用户可根据需求点击左侧节点列表进行节点添加。

随后，添加论文阅读相关的大模型节点，调用大模型生成论文笔记信息；连接节点并编辑信息，依次编辑开始、大模型、结束节点。接着，点击“调试”按钮运行调试；最后，调试通过后点击“发布”，将智能体发布到星火平台、微信公众号或MCP Server等平台。

5.DeepResearch智能体创建

DeepResearch智能体的创建采用模板化方式。第一步进入星辰Agent平台首页，点击创建按钮选择工作流创建；第二步选择模板创建工作流智能体，在弹出的界面中选择与需求相似的模板（如DeepResearch深度搜索模版），点击建同款。

查看模板效果，进行工作流修改和完善，并结合自身需求优化工作流，编辑各节点配置。最后，点击“调试”按钮运行测试。

通过模板化创建，开发者可以在已有成熟方案的基础上快速定制专属智能体，大幅缩短开发周期，尤其适合深度搜索、科研调研等复杂任务场景。

三.从OpenClaw到AstronClaw

既然智能体已经这么强大了，为什么又提出了OpenClaw或AstronClaw呢？它们的优势在哪？

个人感觉主要包括以下几个方面：

1.什么是OpenClaw

OpenClaw是一种面向个人与开发者场景的开源智能体平台，其核心机制以本地或自托管设备为运行载体，通过统一的Gateway将多种通信渠道连接到具备工具调用、会话管理、记忆机制与多智能体路由能力的AI助手之上，使模型不仅能够“生成回答”，更能够“在真实软件环境中持续执行任务”。

OpenClaw由奥地利程序员于2025年11月推出，被称为“AI助手的Kubernetes”。

2.什么是AstronClaw

AstronClaw是基于OpenClaw核心能力构建的云端AI助手或云托管式智能体服务形态。

相较于OpenClaw强调本地自托管与个人控制，AstronClaw更强调云端托管、企业协同与开箱即用，提供7×24小时在线服务，可通过企业微信、钉钉、飞书等企业协同渠道接入，并内置技能系统与官方技能集。平台支持自由切换星火X2、MiniMax-M2.5、Kimi-K2.5等多款大模型，同时还可接入自托管SkillHub，实现一键安装技能、仓库搜索及组织内部自定义技能管理。其核心能力是打造可深度定制的个人AI助手，集成高效技能，实现多渠道信息交互。

3.AstronClaw官方文档

讯飞开放平台中提供了详细的星辰Agent和AstronClaw资料文档和实战案例供大家学习，推荐大家融合自身需求进行实战。

四.AstronClaw基本用法与入门案例

1.AstronAgent一键式部署

AstronClaw的一键式部署流程极为简便。第一步打开官网，点击“立即部署”按钮，进入详细用法介绍页面。

第二步开始对话唤醒AstronClaw，选择合适的大模型并输入提示词；第三步选择官方提供的Agent（如“计划任务”功能）获取AI领域热点咨询新闻推荐。

平台采用沙箱隔离技术运行，全程守护用户数据安全，支持云端一键部署，省去了终端命令、服务器开销与安装烦恼。整个部署过程从零到一开始对话仅需几分钟，真正实现了“开箱即用”的智能体体验。

2.AstronAgent微信渠道交互

AstronClaw支持通过微信渠道进行便捷交互。第一步在AstronClaw主界面点击“渠道”按钮，选择“微信”进入渠道配置页面；第二步点击“未配置”扫描连接微信。

第三步在微信弹出的页面中点击“连接”按钮，在生成的“微信ClawBot”中进行对话。

通过微信渠道，用户可以随时随地向AstronClaw发送任务指令，例如整理智能体相关论文信息、规划旅游攻略等。移动端AstronClaw使手机变成AI“遥控器”，开启“手机指挥、电脑执行”的全新智能协作模式，打破了物理局限，为AI装上了“眼睛”和“耳朵”，实现跨场景任务协同。

那么，移动端AstronClaw的作用在哪？作者归纳如下：

五.Skill驱动的AstronClaw科研实战

1.Astron Skills

Skills是AstronClaw的核心能力模块，相当于Agent可调用的“工具与能力插件”。通过技能，AstronClaw可以从“聊天”升级为“执行任务”。技能主要包括四大类型：

外部工具（搜索/OCR/API）
模型能力（语音/图像/推理）
工作流（多步骤自动执行任务）
行业模板（研报/PPT/分析报告）

平台提供“官方推荐”、“三方精选”和“我的技能”三大模块，用户可前往SkillHub探索更多技能，也可以自主创建技能。这种技能驱动的设计使AstronClaw具备了极强的可扩展性，用户可以根据自身需求不断丰富智能体的能力边界。

2.AstronSkill实现智能简历生成

智能简历生成是AstronSkill的典型应用案例。第一步在官方技能界面中选择“智能简历生成”，点击安装按钮，只需输入个人信息与求职需求，即可即刻量身打造专业简历。

在“我的技能”中下载并剖析该skill的文档结构，推荐大家多学习优秀的skill。

第二步指定技能调用，利用智能简历生成技能构建提示词。

AstronClaw执行read、exec指令生成简历，包括可下载链接及完整文档。整个过程从用户输入到简历生成仅需几分钟，充分体现了Skill驱动模式下智能体的高效执行能力。

3.第三方AstronSkill构建深度研究

深度研究Pro是三方精选中的典型技能。第一步在“三方精选”中选择“深度研究Pro”，点击安装按钮。

同样，我们可以剖析其skill内部结构，理解其工作流程与设计逻辑，更好地撰写属于自己的skill。

随后利用该技能调研智能体的相关研究并查看生成内容，获得结构化的调研报告。通过第三方Skill，用户无需自行编写复杂的搜索与汇总逻辑，即可获得专业级的深度研究成果，极大提升了科研效率。

六.智能编程实践案例分析

1.AstronClaw赋能编程开发

AstronClaw赋能智能编程，是将代码生成、工具调用、任务执行与持续协同融为一体，使AI从“辅助写代码”升级为“能够理解需求、联动环境并完成开发任务的智能编程伙伴”。

步骤一：利用AstronClaw自动生成代码，构建详细提示词开发五子棋网页小游戏。

步骤二：AstronClaw调用内置Skill和智能体完成程序开发。

步骤三：下载或访问AstronClaw生成代码进行验证。

步骤四：网站运行及部署上线。

建议在云端服务器配置AstronClaw，调用智能体进行开发，生成代码项目库与本地VSCode绑定，实现自动化、智能化的实时开发。

更多智能体赋能编程与开发的案例，请大家下来尝试。

2.创建自定义Skill赋能科研编程

创建自定义Skill是科研编程的重要能力。第一步在主界面点击“创建skills”按钮。

结合自身需求搜索或创建Skill内容，指导智能体执行相关任务。

https://github.com/K-Dense-AI/scientific-agent-skills

GitHub上提供了科学技能工具包仓库（K-Dense-Al/scientific-agent-skills），当前提供133个现成技能，覆盖生物信息学、药物发现、临床研究、医学影像、机器学习、材料科学、物理天文、地理空间分析、实验室自动化、科学写作等方向。

最后结合自构建AI4S科学研究智能体，上传科学技能工具包zip文件。核心能力涵盖查数据和接数据库、科研分析、连接科研平台与实验环境、科研表达与文档生成等。

3.课程案例展示

最后，作者展示了几个代表性AstronClaw赋能编程与开发的案例，并且与大家进行了交流。

（1）网站开发案例

（2）桌面应用程序开发

（3）知识图谱开发案例

总结

从星辰智能体的平台构建到AstronClaw的云端部署，从MCP协议的底层通信到Skill驱动的任务执行，智能体技术正在以前所未有的速度重塑校园场景下的教学、科研与编程实践。希望本文能够为高校师生和AI开发者提供一份系统性的参考指南。如果您在智能体开发与使用过程中有任何疑问或心得体会，欢迎在评论区留言交流。让我们共同拥抱智能体时代，用AI赋能教与学的每一个环节！

温馨建议：

长记忆可以尝试每次保留一个版本，使用前输入让智能体唤起记忆做后续开发和迭代更新。
在使用大模型或智能体开发过程中，要学会版本迭代，智能体skill也可以持续维护，阶段性更迭效果会更好。
在利用智能体科学研究时，学会将整体框架搭建，并分任务实现不同需求（如数据预处理、数据分析、可视化），并生成阶段结果作为下一阶段输入。
如何利用云端和本地交互，实现智能体开发至关重要，云端配置智能体再利用VS Code访问可解决部分问题。

文章写到这里就结束了，写得不好的地方，还请海涵！未来，随着智能体能力的不断增强，人机协作模式将进一步深化，开发者的角色也将从“代码编写者”转变为“任务设计者”。理解并掌握这一趋势，将成为新时代技术人才的重要能力。

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

(By:Eastmount 2026-04-23 周四夜于贵阳)

跳转微信打开

[AI安全论文] (49)JNCA24 网络威胁狩猎演化技术综述

Sun, 12 Apr 2026 18:11:00 +0800

原创 YZX 2026-04-12 18:11 贵州

网络威胁情报狩猎综述，希望您喜欢！

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

前一篇博客介绍了APILI，一种面向恶意软件行为分析的深度学习方法，用于在动态执行轨迹中定位与恶意攻击技术（MITRE ATT&CK Techniques）相对应的底层 API 调用。本文是一篇系统性综述论文，详细综述了网络威胁狩猎技术，探讨了智能本体与自动化工具的资源整合路径，涵盖了监督与无监督学习、推理机制、图方法及规则方法等多种建模策略，并分析了关键挑战和困难。注意，由于我们团队还在不断成长和学习中，写得不好的地方还请海涵，希望这篇文章对您有所帮助，这些大佬真值得我们学习。fighting！

文章目录

一、研究背景与总体概述

1.研究缘起与背景
2.研究目标与核心问题

二、研究方法与文献筛选流程
三、威胁狩猎的理论与流程框架（RQ1)

1.威胁狩猎与异常检测的关系
2. 系统化的狩猎流程

四、数学假设模型（RQ2）

1.隐状态与观测模型
2.威胁指示函数
3.异常检测与猎捕的协同数学模型
4.迭代式假设模型

五、主要研究方法分类与演化趋势（RQ3）

1. 监督学习方法
2. 无监督学习方法
3. 推理与逻辑方法
4. 图模型与知识图谱方法
5. 规则与行为驱动方法
6. 其他方法

六、主要研究挑战（RQ4）

1.高质量标注数据稀缺
2.数据不平衡与类别稀疏问题
3.多源异构数据融合困难
4. 对抗性攻击快速演化
5. 人类专家稀缺与知识成本高昂

七、未来发展方向与启示
八、学术价值与创新贡献

原文作者：Arash Mahboubi, et al.
原文标题：Evolving Techniques in Cyber Threat Hunting: A Systematic Review
原文链接：https://www.sciencedirect.com/science/article/pii/S1084804524001814
发表期刊：Journal of Network and Computer Applications 2024

一.研究背景与总体概述

1.研究缘起与背景

在网络攻击不断演化、传统防御手段逐渐失效的时代，威胁狩猎（Cyber Threat Hunting, CTH） 成为网络安全领域的主动防御前沿。与被动的入侵检测系统（IDS）或事件响应机制（IR）不同，威胁狩猎旨在通过分析潜在行为模式、构建攻击假设、挖掘隐匿迹象，在攻击造成损害前主动发现对手。

论文指出，近年来：

全球活跃攻击组织已超230个；
eCrime平均突破时间仅2分钟；
无文件攻击（Malware-free Attacks）与AI辅助社会工程攻击显著增加。

这表明传统基于签名或规则的检测系统难以应对动态威胁，网络防御迫切需要转向 “预测性安全与假设驱动分析” 的新范式。

2.研究目标与核心问题

作者通过系统综述（Systematic Literature Review, SLR）方法，明确提出了四个研究问题：

序号	研究问题（RQ）	研究核心
RQ1	威胁狩猎技术与方法如何演化？	分析从手动调查到AI驱动的转变过程。
RQ2	威胁狩猎中是否存在可形式化的数学假设模型？	探讨可量化、可推理的威胁假设构建方法。
RQ3	当前主流的狩猎策略与算法有哪些？	系统比较监督学习、无监督学习、图模型等方法。
RQ4	现阶段的主要技术与实践挑战是什么？	概括数据、算法与人力资源的关键限制。

二.研究方法与文献筛选流程

论文遵循SLR标准流程：

初步检索阶段
从IEEE、ACM、Scopus、Google Scholar等数据库检索1696篇相关文献。
筛选阶段
根据主题关键词（如“threat hunting”、“security analytics”、“intrusion detection system”等）过滤至287篇。
评估阶段
剔除综述、海报及简报类文献，最终保留117篇实证与方法研究论文。

文献被划分为四类以对应研究问题：

12篇：威胁狩猎流程研究（RQ1）
4篇：假设建模研究（RQ2）
63篇：威胁检测方法（RQ3）
38篇：挑战与难题研究（RQ4）

三.威胁狩猎的理论与流程框架（RQ1)

1.威胁狩猎与异常检测的关系

异常检测（Anomaly Detection）
自动识别偏离常态的行为模式
威胁狩猎（Threat Hunting）
基于情报与假设的主动探索行为

论文强调二者相辅相成：
威胁狩猎通过人类推理发现新威胁 → 为异常检测提供新特征与标签；
异常检测通过算法扩展威胁覆盖面 → 为狩猎提供数据支撑。

2. 系统化的狩猎流程（Ten-Step Model）

基于SANS威胁狩猎成熟度模型，作者提出了十步过程：

异构数据收集
威胁定义与假设制定
主动搜索与行为验证
威胁指标识别（IoC/IoA）
威胁分类与聚类
人工验证
防御体系比对与漏洞评估
模式与特征提取
防御系统改进（IDS、EDR、SIEM）
迭代更新与知识反馈

这一循环体现了“假设—验证—修正”的持续狩猎思想。

四.数学假设模型（RQ2）

论文指出：威胁狩猎的核心在于“假设驱动（Hypothesis-driven）”，但行业长期缺乏形式化、可量化的数学模型。作者选取 4 篇关键文献，对假设建模进行分类与总结。

1.隐状态与观测模型

许多威胁行为不可直接观测（如横向移动、隐蔽持久化），只能通过系统事件、日志等“观测值 O” 推断攻击者“隐状态 H”。

该模型类似于隐马尔可夫模型（HMM）思想（论文没有直接使用 HMM，但思想一致）：

H：攻击者当前所处的战术阶段
O：日志、行为、网络流量等可见事件
f(H,O)：威胁指示函数（Indicator Function）用于评估风险信号

论文提出可通过概率分布或启发式规则连接隐状态与观测，从而构建“攻击轨迹推断”。

2.威胁指示函数

论文提出“威胁指示函数 I(O)”概念，用于量化观测行为与潜在威胁之间的关联度，是数学化假设模型的关键要素。

作用：

从复杂、噪声较多的日志中筛选风险事件
将行为分布、情报关联度等信息映射为“威胁评分”
用于指导初始假设是否成立

示例形式：

I(O) = g(features, context, intelligence)

其中 g 可以是

聚类结果得分
图匹配相似度
行为异常度（如 Reconstruction Error）
ATT&CK TTP 匹配程度

论文强调：
威胁指示函数是打造半自动化猎捕模型的核心组件。

3.异常检测与猎捕的协同数学模型

论文将“异常检测-威胁狩猎”关系建模为一种双向迭代机制：

异常检测提供行为概率分布 P(O)，帮助猎捕者定位可疑区域；
猎捕者根据推理生成新的假设 H，并补充新的攻击特征；
异常检测模型基于新的特征与标签得到改进；
系统进入下一轮循环。

这种模型可形式化为：

Hᵢ₊₁ = Update(Hᵢ, I(O), P(O))

其中 Update 表示“基于数据—情报—推理的假设修正过程”。

论文指出，这种“协同模型”具有高度潜力，可成为未来自动化猎捕系统的理论基础。

4.迭代式假设模型

论文认为：威胁狩猎不是一次性推理，而是连续迭代的假设更新过程。

流程结构为：

构建初始假设（H₀）
基于情报、规则、经验
数据观察（O₀）
收集日志、事件、流量
更新假设（H₁）
根据 O₀ 的结果修正原假设
验证（Validate）
人工或自动验证
生成下一阶段假设（H₂, H₃…）

五.研究方法分类与演化趋势（RQ3）

论文将 63 篇方法性研究归纳为六类：

监督学习（LSTM、CNN、Transformer）
无监督学习（聚类、Autoencoder、LDA）
推理方法（知识图谱、本体、因果推理）
图模型/GNN（DeepHunter, ANUBIS）
规则与TTP驱动（MITRE ATT&CK）
其他方法（强化学习、自监督学习）

每类方法论文均给出其特点、适用场景与局限。

1. 监督学习方法（Supervised ML）

模型：LSTM、CNN、SVM、Random Forest、Transformer。
应用：恶意软件分类、APT路径预测、IIoT威胁检测。
示例：

DRTHIS
（Homayoun, 2019）利用深度学习识别勒索软件；
DeepAG
（Li, 2023）用Transformer预测APT攻击链；
ATHRNN
（Liu, 2022）结合Transformer与知识图谱提取ATT&CK技术。

📌 特点：性能高、可解释性有限、依赖标签数据。

2. 无监督学习方法（Unsupervised ML）

技术：Autoencoder、聚类、Word2Vec、LDA主题建模等；
应用：日志异常检测、威胁模式聚类、事件归因；
示例：

LogAnomaly
（Meng, 2019）基于LSTM的日志异常检测；
THREATRAPTOR
（Gao, 2021）自动化威胁行为提取系统。

📌 特点：适用于未知威胁与无标签环境，但存在误报问题。

3. 推理与逻辑方法

融合知识图谱、逻辑推理与因果模型；
示例：

Narayanan, 2018
基于本体的知识图推理；
Marin, 2020
将社会行为与技术特征结合的攻击预测模型；
Dritsoula, 2017
基于博弈论的攻击者策略建模。

📌 特点：增强可解释性，适合假设生成与高层策略分析。

4. 图模型与知识图谱方法（Graph-based & GNN）

代表模型：Poirot、DeepHunter、ANUBIS、AttackDB；
应用：APT溯源、攻击路径推断、威胁知识推理；
技术：Provenance Graph、Graph Neural Networks (GNN)、GraphSAGE、Link Prediction。

📌 趋势：成为当前威胁狩猎的核心方向，可视化攻击链与推理攻击阶段。

5. 规则与行为驱动方法（Rule-based Approaches）

特点：依托MITRE ATT&CK与STIX等标准知识库；
典型：SteinerLog、ProvTalk、_HERCULE_等；
关注：多阶段攻击重建与TTP映射。

6. 其他方法

强化学习与多臂老虎机模型（MABAT）
优化威胁数据采集策略；
UEBA行为分析
通过用户行为异常识别内部威胁；
生成式AI与LLM在威胁建模中的应用
未来趋势之一。

六.主要研究挑战（RQ4）

论文综合 38 篇相关工作，对威胁狩猎领域当前的核心挑战进行了系统化归纳。作者将挑战分为 数据层、方法层、对抗层、资源层 四大方向，共五项关键难题。这些挑战解释了为何威胁狩猎自动化难以完全落地，并为未来研究路径提供方向指引。

1.高质量标注数据稀缺（Challenge 1）

威胁狩猎高度依赖 高可信标签、攻击场景、系统行为上下文，但现实中存在：

攻击样本稀少且分布极不平衡；
企业内部攻击事件很少公开；
多数 APT 场景无法真实重建；
大部分研究仅依赖少量公共数据集（如 DARPA、CICIDS）。

缺乏标注数据导致：

监督学习难以训练稳健模型；
模型容易过拟合特定环境；
难以构建跨域、通用的威胁检测能力。

2.数据不平衡与类别稀疏问题（Challenge 2）

在大型 SOC 环境中，恶意事件通常只占全部日志的 0.01%—0.1%。

论文指出：

绝大部分机器学习模型在此环境下会偏向正常类；
工具难以学习“异常且隐蔽”的攻击行为；
对于 APT 这类极低频事件，模型识别能力常常不足。

因此需要针对稀疏样本与不平衡数据设计更适合的算法（如异常检测、重采样、自监督学习等）。

3.多源异构数据融合困难（Challenge 3）

威胁狩猎需结合来自不同系统的多模态、多结构数据，例如：

系统调用日志
网络流量
Windows 事件
EDR/AV 行为追踪
SOAR/SIEM 告警
OSINT/CTI（开源威胁情报）

然而：

数据格式、时间戳、语义差异巨大；
无法轻易对齐到统一的攻击链上下文；
跨源推理的关联性弱，容易导致误报/漏报。

论文认为异构数据融合是当前威胁猎捕自动化系统的最大瓶颈之一。

4. 对抗性攻击快速演化（Challenge 4）

现代攻击呈现出快速进化趋势：

对抗样本（Adversarial Examples）影响 ML 模型判断；
AI 生成内容用于社会工程、伪造数据；
零日漏洞与“无文件攻击”难以通过传统模式识别；
APT 组织不断改变行为，使基于历史特征的模型迅速过时。

论文强调：

回溯式学习（Retrospective Learning）无法跟上攻击者动态演进速度
需要新的“预测性、推理型、假设驱动”的方法。

5. 人类专家稀缺与知识成本高昂（Challenge 5）

威胁狩猎依赖经验丰富的分析师，但现实中：

高级分析师储备严重不足；
组织之间缺少高质量知识共享机制；
即便自动化工具强大，专家仍需为模型输出提供最终判断；
威胁情报（TI/CTI）的可信度与更新速度无法持续保障。

论文指出，即使自动化能力提升，“人机协作”仍将是未来长期状态，而人力短缺会继续制约威胁猎捕能力的提升。

七.未来发展方向与启示

AI驱动智能狩猎系统
结合生成式AI、强化学习、自动假设生成；
可解释与数学化模型
基于隐马尔可夫模型（HMM）等进行威胁状态建模；
知识图谱与自动推理结合
实现威胁情报、攻击路径、战术模式的统一；
人机协作与自动化融合
在SOAR框架中嵌入人类分析循环；
多模态数据与自监督学习
提升无标签环境下的威胁识别性能。

八.学术价值与创新贡献

论文总结如下：

建立了威胁狩猎研究的系统分类框架；
提出“假设建模+迭代验证”的数学形式化思路；
综合评估了机器学习、知识图谱、逻辑推理、自动化工具等多维方法；
总结了数据集、工具（MITRE、MISP、OpenCTI等）及开源资源；
指明AI与人类专家协同的未来方向。

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

(By:Eastmount 2026-04-12 周日夜于贵阳)

前文推荐：

跳转微信打开

《AI Coding入门与实战》开源课程分享：第5课基于iFlyCode的桌面应用程序开发（AI大学堂）

Tue, 03 Mar 2026 10:38:00 +0800

原创杨秀璋 2026-03-03 10:38 贵州

本文详细讲解AI赋能桌面应用程序开发，希望您喜欢！

在大模型技术快速演进的背景下，软件开发正经历从“代码书写驱动”向“智能语义驱动”的范式转型。AI Coding 作为这一转型的核心形态，依托大语言模型的理解、生成与推理能力，使开发者能够通过自然语言表达需求，由 AI 协同完成代码设计、实现与优化。这种新模式正在显著降低编程门槛、提升开发效率，并推动软件工程进入智能协作时代。

本系列课程《AI Coding入门与实战》由科大讯飞与 CSDN 合作推出，并在“AI大学堂”平台面向公众开放。课程以大模型技术和AI Coding为基础，以真实开发案例为载体，系统讲解 AI Coding（iFlyCode）的理论框架、技术原理与工程实践场景。在此特别感谢科大讯飞在大模型与智能编程工具领域的技术支持，以及 CSDN 在开发者生态建设方面的持续推动，使该课程得以面向更广泛学习者。

我们诚挚建议对人工智能编程、智能开发工具以及未来软件工程形态感兴趣的学习者，前往 AI大学堂平台系统学习本系列课程。课程涵盖从概念认知、工具使用到项目实践的完整体系，适合高校学生、科研人员及工程开发者持续进阶。学习者可在 AI大学堂官方网站或课程平台中搜索课程名称：

AI大学堂官网：https://www.aidaxue.com
《AI Coding入门与实战》第1课 AI Coding概念与大模型赋能编程
《AI Coding入门与实战》第2课基于通用大模型的代码生成
《AI Coding入门与实战》第3课 iFlyCode入门与数据分析实战
《AI Coding入门与实战》第4课基于iFlyCode的网页开发实战【本博客的学习视频地址】
《AI Coding入门与实战》第5课基于iFlyCode的桌面应用程序开发
《AI Coding入门与实战》第6课基于iFlyCode的安全知识图谱构建
《AI Coding入门与实战》第7课基于iFlyCode的图书管理网站系统开发
《AI Coding入门与实战》第8课 iFlyCode智能体开发与课程总结

代码开源地址：

https://github.com/eastmountyxz/AI-Coding-iFlyCode

本课以“AI辅助桌面应用开发”为主线，围绕 iFlyCode 的代码生成与迭代能力，构建从需求抽象、提示词工程、界面开发到图像处理算法集成与应用发布的完整实践链条。课程选取 Python + Tkinter 作为桌面端GUI载体，并以 OpenCV 图像处理/识别为算法能力来源，形成“交互界面—算法模块—工程部署”三位一体的教学闭环。相较于仅面向脚本编写的AI Coding示例，本课更强调工程语境下的模块化结构、可复用组件、可运行交付与可解释的提示词迭代，从而使学习者能够在真实业务需求中完成从原型到可用系统的过渡。课程目录如下：

文章目录

一.课程学习目标

1.课程概况
2.实战效果

二.桌面应用程序开发基础

1.桌面应用程序的基本定义
2.C/S与B/S架构
3.桌面应用程序开发常用工具与框架
4.基于Python的桌面应用程序开发
5.iFlyCode桌面应用开发的基本流程

三.Python图像处理与识别基础知识

1.图像处理与识别的基本定义
2.图像基础知识
3.OpenCV基础知识
4.图像灰度处理案例分析
5.图像锐化处理案例分析

四.基于iFlyCode的窗口程序及界面设计

1.主界面窗口生成
2.代码优化与精准提示构建

五.基于iFlyCode的图像处理系统开发实战

1.图像灰度处理代码实现
2.图像镜像处理代码实现
3.其余图像处理代码实现

六.基于iFlyCode的人脸识别系统开发实战

1.人脸识别系统开发
2.桌面应用系统发布及部署

七.课程总结与课后实践作业

一.课程学习目标

1.课程概况

该课程系统讲解AI Coding入门及实战应用内容，涵盖AI Coding基本概念、主流AI Coding工具及应用。课程以项目驱动为导向，基于科大讯飞iFlyCode工具，从数据分析、网页制作、图像处理、桌面应用编程、网站开发、科学研究编程等经典场景，详细讲解大模型赋能AI Coding的过程及用法，逐步培养初学者掌握AI辅助编程的能力，帮助其实现从基础入门到综合应用的跨越。课程兼顾理论与实践，注重工具操作、案例分析和编程思维的培养，旨在让大家真正能在编程开发、科研与工作中高效使用AI Coding，建立起AI Coding从零到一的过程。

第5次课《基于iFlyCode的桌面应用程序开发》旨在利用科大讯飞iFlyCode工具开发桌面应用程序及系统。以Python图像处理与图像识别为研究对象，开展图像处理桌面应用系统的开发实战案例，让大家快速掌握客户端应用程序AI Coding知识。

2.实战效果

桌面应用程序开发的实战效果如下图所示：

二.桌面应用程序开发基础

1.桌面应用程序的基本定义

首先从概念层面对桌面应用程序进行界定，强调其“本地运行、无需浏览器依赖、直接在操作系统环境中执行”的属性。这一界定凸显桌面应用在性能与交互方面的优势：其可以更充分地调用本地计算资源与系统API，适合处理图形处理、办公软件、数据分析等对交互延迟和计算吞吐要求较高的任务。

与Web应用相比，桌面应用在用户体验与系统能力调用上具备更强的确定性，尤其在涉及本地文件系统读写、摄像头/传感器接入、图像视频处理等场景时，桌面端通常能以更少的中间层完成能力落地。

同时，桌面应用具有“操作系统依赖性”，即需要针对Windows、macOS、Linux等平台分别适配或打包，这意味着桌面应用开发不仅是编程问题，也是工程分发与运行环境治理问题。

2.C/S与B/S架构

以客户端/服务器（C/S）与浏览器/服务器（B/S）架构对比，引导学习者理解桌面应用在信息系统中的结构位置。C/S架构通常由本地客户端承担较多交互与部分计算逻辑，服务器负责集中处理与数据存储，其优势在于较高的安全性、集中管理能力以及可扩展的分布式协作机制；典型应用包括企业ERP、即时通信软件、数据库客户端等。

3.桌面应用程序开发常用工具与框架

桌面应用开发并不只有单一路线，开发框架的选择会深刻影响界面能力、跨平台性、部署方式与后续维护成本。课程最终选用 Tkinter 作为实践框架，更好地帮助初学者学习如何与iFlyCode交互。

4.基于Python的桌面应用程序开发

本节明确采用 Tkinter 作为桌面GUI实现方案，并以“导入库—创建主窗口—设置标题与尺寸—进入主循环”等步骤展示其基本用法。这一部分的重要性在于建立桌面程序的最小可运行单元：只要主窗口能稳定启动，后续的按钮、菜单、画布与图像显示等功能才能以“增量迭代”的方式叠加。在AI辅助开发场景中，最小可运行单元尤为关键，因为它是验证生成代码是否正确接入框架运行机制的首要指标，也是后续提示词迭代的稳定基座。

Tkinter 的价值在于其与Python生态高度耦合，能够方便地与 OpenCV、NumPy 等计算库组合，并以较低门槛完成“界面+算法”的集成。

5.iFlyCode桌面应用开发的基本流程

该部分给出其基本流程，生成式开发区别于传统开发，开发活动从“直接编码”转向“以需求与约束为中心的生成—验证—修正循环”。其中，“提示词构建”并非简单描述功能，而是需要将界面结构、控件交互、算法能力、输入输出格式、异常处理等要素结构化表达，使模型能够在明确约束下生成可运行代码。

三.Python图像处理与识别基础知识

1.图像处理与识别的基本定义

本节对图像处理与图像识别进行基础界定：

图像处理通常面向像素级变换与增强，包括灰度化、滤波、锐化、对比度增强等；
图像识别则更强调从图像中提取可解释语义，如人脸检测与识别等任务。

2.图像基础知识

对于AI辅助开发而言，理解图像的基本数据结构至关重要，因为 GUI 与算法模块之间的接口往往以“数组/矩阵对象”或“图像文件路径”来传递信息。若学习者缺乏对图像数据表征的理解，则在集成OpenCV处理结果与Tkinter显示时容易出现类型不匹配、颜色通道错误或尺寸缩放失真等工程问题。

3.OpenCV基础知识

本节给出 OpenCV 的安装与导入方式，并明确其与 NumPy 的协同关系（OpenCV负责图像I/O与算法算子，NumPy负责数组计算与数据结构承载）。对于使用 iFlyCode 生成代码的学习者而言，明确依赖（如 opencv-python、numpy）不仅有助于生成正确的 import 与函数调用，也为后续打包部署时的依赖收敛提供清晰边界。

4.图像灰度处理案例分析

以灰度处理作为典型案例，强调其作为图像预处理步骤在视觉增强、特征提取与后续识别任务中的基础。灰度化将彩色图像从多通道映射到单通道强度表示，从而降低计算复杂度，并使边缘、纹理等结构信息更容易被后续算子捕获。

5.图像锐化处理案例分析

Sobel 算子作为锐化/边缘检测的代表方法，强调其通过离散微分计算图像亮度变化近似值，从而突出边缘结构。在桌面应用中，锐化功能常用于提升细节可见性，也可作为识别系统的特征增强手段。将其纳入课程实践，能够让学习者在应用层面直观观察参数与输出效果之间的关联，从而形成对图像处理算子可解释性的基本认知。

四.基于iFlyCode的窗口程序及界面设计

1.主界面窗口生成

在本节展示“图像处理桌面应用系统案例”的总体开发路径，并明确以 Tkinter 构建主界面作为基础。其方法论核心是“先搭骨架、再填功能”，通过生成可运行的窗口框架，将图像载入、显示区域、功能按钮区与状态提示区等交互要素纳入统一布局，确保应用具备清晰的信息流与操作流。对于桌面应用而言，主界面不仅是视觉呈现，更是事件驱动体系的载体：每一个按钮、菜单项与输入控件都对应回调函数入口，决定算法模块如何被触发、如何接收参数并如何输出结果。

在 iFlyCode 场景下的提示词构建：需要明确要求使用 Tkinter 构建图像处理桌面应用，并设定功能模块、界面布局与交互逻辑。该提示词实践体现了生成式开发的关键原则——需求表达必须结构化，尤其要说明窗口组件、按钮名称、触发功能、图像显示方式与错误处理策略等内容。

在真实开发过程中，项目需要模块化开发，部分功能会在后续持续编程中实现。那么，AI Coding能否持续优化我们的项目呢？

2.代码优化与精准提示构建

本节将重点转向“代码优化”与“精准提示”，并明确后续需要在主界面基础上补充灰度处理、镜像、直方图均衡化、Sobel锐化、均值滤波等功能。读者可结合星火、DeepSeek等大模型构建更丰富提示词，以提升代码质量与可维护性。

五.基于iFlyCode的图像处理系统开发实战

1.图像灰度处理代码实现

本节将实现图像灰度处理功能，并在主界面基础上拓展，以实现版本演进与增量开发。

注意：与前面课程内容不同，这里的代码是在上一小节所生成Python文件的基础上优化，从而实现更丰富的功能！

此外，在AI Coding提示词与代码生成过程中，桌面应用可能出现“结构不一致、变量命名冲突、状态未同步”等问题，因此灰度模块实现不仅要写出算法调用，还要确保其与主界面状态管理一致，如何利用AI优化代码至关重要。

2.图像镜像处理代码实现

接着实现图像镜像处理功能。桌面应用若要具有工具属性，功能不应仅以单一路径实现，而应考虑用户对操作选项的需求，例如镜像方向、是否覆盖原图、是否保存输出等，同时必须保证图像对象在系统中的生命周期清晰可控。因而，在提示词层面需要明确镜像类型与UI交互方式，促使模型生成更贴近真实产品需求的代码结构。

3.其余图像处理代码实现

在本节将直方图均衡化、Sobel锐化、均值滤波等多个功能作为“后续三个功能”进行集中推进，并提出“精简提示词”的要求。通过“精简提示词”的练习，学习者应掌握将重复需求抽象为通用模板的能力，从而使生成式开发在规模化功能扩展时仍保持可控。

总之，该课程将“AI生成能力”引导到“工程组织能力”的轨道上，使学习者不仅能做出功能，更能维持系统随功能增长而不失控。

六.基于iFlyCode的人脸识别系统开发实战

1.人脸识别系统开发

在本节将案例从“图像处理”推进到“图像识别”，并以人脸识别系统作为代表性任务。课程在此强调仍遵循相同的iFlyCode开发路径，其关键在于将识别任务拆解为桌面应用可实现的子流程，例如摄像头/图片输入、检测与标注、结果展示与日志输出等，使识别能力以可交互方式嵌入应用，而非停留在命令行脚本层面。

2.桌面应用系统发布及部署

在本节聚焦桌面应用交付的最后一公里——将 Python + Tkinter 程序打包为 Windows 可执行文件（.exe），并给出以 PyInstaller 为代表的打包路径。最终，课程形成从“生成—运行—扩展—打包”的闭环，使学习者掌握可迁移到真实项目的桌面应用开发方法体系。

对于AI生成代码而言，部署环节常暴露隐藏问题，例如依赖库未正确包含、资源文件路径在打包后失效、OpenCV相关动态库加载异常、以及不同Windows环境下的兼容性差异。课程将打包部署纳入课程，体现其对工程完整性的要求，也符合企业应用对可交付性的基本标准。

七.课程总结与课后实践作业

本课程系统展示了 AI Coding 在桌面应用程序开发中的完整路径，构建了“提示工程—代码生成—工程部署”的现代软件开发教学模式，为 AI 时代编程教育提供了实践范式。课程总结如下：

桌面应用程序开发基础
Python图像处理与识别基础知识
基于iFlyCode的窗口程序及界面设计
基于iFlyCode的图像处理系统开发实战
基于iFlyCode的人脸识别系统开发实战
iFlyCode上下文编程对话用法

科大讯飞的AI大学堂开源视频地址，强烈推荐大家去学习。

《AI Coding入门与实战》第5课基于iFlyCode的桌面应用程序开发

本课程的开源实践（GitHub: AI-Coding-iFlyCode）为后续教学与研究提供了宝贵的资产。

https://github.com/eastmountyxz/AI-Coding-iFlyCode

本次课程的作业如下：

课程作业1：请了解桌面应用程序开发及图像处理基础知识。
课程作业2：请结合课程内容利用iFlyCode开发中文和英文翻译软件的桌面应用程序。
课程作业3：请利用iFlyCode开发图像处理与识别桌面应用系统。
课程作业4：请利用iFlyCode开发具有网络通信功能的对话客户端系统，能在两个界面进行对话聊天。

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

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

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

跳转微信打开

2025年总结：微光如盏，谦以致远，万家灯火中的一小盏

Wed, 18 Feb 2026 10:35:00 +0800

原创杨秀璋 2026-02-18 10:35 贵州

2025年终总结，感谢大家这一年的支持，感恩！

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

曾记否，2013年感叹《一万年太久，只争朝夕》；2014年本科毕业写下《忆大学四年的得与失》；2015年选择回贵州工作，《再见北理工》依依不舍；2016年初为一名大学青椒，《教师路的开启，爱情味的初尝》；2017年又借调到省发改委学习忙碌一年，留下《人生百味，有你真好》；2018年数不清的加班，尝不尽的酸甜，《向死而生，为爱而活，忆编程戎马岁月》；2019年奔波考博重返校园，两人通过书信寄托情感，《把能努力的都努力好，最终等待命运垂青》；2020年小珞珞降生，《敏而多思，宁静致远》，希望他永远记住妈妈的辛苦；2021年已为人父，三十而立不再年轻，写下《缘起性空，归来不少年》；2022年异地读博艰辛，家人鼓励，《为梦想擦去蒙尘，愿大家健康平安快乐》；2023年博士毕业，《雄关漫漫真如铁，而今迈步从头越》。

那么，2025年和2024年又写些啥？2024年，自己换了新的工作，很荣幸成为了贵州大学的一员，这一年因为年底要写国基，心中默默许下“国基不中，年终总结停更”，因此错过了去年的年终总结。很幸运，25年开奖命中，因此，值此新春之际，回顾下2025的得与失。这一年，确实发生了很多事，科研、教学、工作、竞赛、分享，今朝得失，仿佛如昨。这一年，更感叹家人和亲情的温暖，责任和陪伴的重要，我们都是万家灯火中的一小盏，没有什么比家人更珍贵，微光如盏，谦以致远。寥寥数笔，仅记录这酸甜苦辣的一年，希望您喜欢！

文章目录

一.微光如盏，谦以致远

科研总结
教学总结
技术总结
竞赛总结

二.万家灯火中的一小盏

亲情最美
陪伴最美

三.2026年展望

一.微光如盏，谦以致远

这一年，除参与实验室组建和学校日常工作外，在科研、教学和技术中也做了些事。

科研总结

这一年，在忙碌中发表和录用了6篇论文，包括4篇SCI论文（SCI二区2篇）和2篇核心论文。其中，XLM4Detector实现了Excel宏代码恶意软件的解混淆和识别；CTI-thinker是团队首篇融合大模型和RAG对威胁知识抽取和推理的研究；SWJZ2Vec说文解字模型实现了古籍的实体识别；发表在《软件学报》的《面向APT攻击的溯源和推理研究综述》，通过50页的内容对自己博士四年的研究进行总结。同时，还有幸参与了8篇论文的发表，在此感谢这一年所有指导和帮助我的老师。

这一年，非常幸运中了四个课题，修改了150多稿的国家自科立项，虽是地区也是自己的心血，希望未来四年能深入研究下“面向高隐蔽攻击的行为检测及溯源推理关键技术”。同时，有幸参与的算力安全省重大专项和主持的两个省级项目也需加油。2025年底，自己第一次获批了省社科项目，“中华民族共同体视域下濒危水书的数智化保护研究”，亦是对自己多年数字人文第二个方向的鼓励，真心希望能为家乡文化保护贡献一丝力量。再次感谢学校和团队的帮助，以及指导我们的老师。

这一年，与好伙伴们合作撰写的四本专著上市，也见证了与伙伴们多年的友谊。《Deepseek赋能日常办公与科学研究开发实践》是自己第一部大模型相关书籍，期待未来Codebuddy、提示工程、智能体、AI安全、Openclaw技术的总结。在此感谢北京航空航天大学出版社、机械工业出版社、人民邮电出版社及编辑老师，感谢超哥、香香老师、杜老师等的合作与支持。感谢2025，始终有一群一起拼搏和深夜交流技术的朋友。

这一年，申请了4个发明专利，有幸参与了3个专利的授权和1个标准的发布。这一年，中国知网再次成为了全国高被引学者5%，未来不知道能否进入全球的高被引学者，感觉难。这一年，有幸成为了科大讯飞大模型领域专家及荣誉讲师，受聘担任人民邮电异步社区图书出版专家顾问。这一年，有幸参与的安全项目荣获新闻行业领域的科技三等奖。

这一年，还有太多科研经历记录于心。大家往往看到的只是一个个数字，看到的是老师有两个假期，然而，这每一份成果的背后都是科研人日夜的艰辛，都是赶车出差途中的忙碌，都是学校与团队背后的支持，都是家庭背后的付出，唯有感恩。大学老师轻松吗？未必。回想起每次带娃补课，他在里面学习，我在外面学习；每次节假日出去旅行，都要背上比几块砖还重的外星人，感慨。2025已悄然逝去，2026希望大家在科研之余，还是多些陪伴，多些锻炼，少些内卷。

教学总结

2025年的九月，我终于拿到了教师资格证。说来惭愧，2016年就成为了一名大学教师，今天才拿到这个证。然而，人生嘛，不是什么事情都总能让人满意的，挫折未必是坏事（自我安慰）。

这一年，自己首次尝试了新工科和新文科的创新教学，在贵州大学阳明学院给大一新生开设了《数字人文技术及运用》通识课程。周二下午的四节连堂，从周五到周一感觉都在备课，融合大模型与贵州特色文化的课程知识，从阳明文化到侗族大歌苗族刺绣，再到濒危水书、屯堡傩戏文化，再到中华民族文化和全国各地非遗数字活化，每次课程都与前沿AI数字化技术进行了融合。确实，教书是一名良心活，只求问心无愧。学生们做的作业和作品我还真挺满意的，尤其看到你们积极融合课程去竞赛，去创新。这一刻，足矣！

第1课走进数字人文：从古籍保护到AI大模型数智化技术
第2课用数据可视化技术探索阳明心学的贵州足迹
第3课古籍数字化保护与危水书智能化识别
第4课非遗数字化探索：侗族大歌与苗族刺绣图腾识别及挖掘
第5课清水江文书数字化整理与古诗词本体及数字人构建
第6课数字人文视角下的贵州生态红色旅游评论智能分析与文创探索
第7课非物质文化遗产数字保护与贵州特色文化数字化传承
第8课新文科视野下的数字人文拓展与实践——大一新生能做什么与怎么做

这一年，有幸给实验室的研究生分享了《信息系统安全》和《人工智能安全》课程，代码实战与科研普及的方式，只求学生们能尽快进入研究生状态，开启自己的第一篇学术论文，融合最新的AI技术。

这一年，与科大讯飞和CSDN合作，联合推出了《AI Coding入门及应用》开源课程。通过八次课程详细概述了iFlyCode如何赋能网站开发、桌面应用程序开发、知识图谱构建以及智能体开发，第二次课已超过万人学习。让世界享受AI的魅力，欢迎大家去讯飞的AI大学堂学习，感谢讯飞和CSDN。

https://github.com/eastmountyxz/AI-Coding-iFlyCode

师者，传道授业解惑也。希望自己能保持初心，如2016年放弃北京互联网选择回家乡教书一样，认真对待每一名学生。还是那句话，“每当看到一双双求知的眼神，恨不得把所有知识都倾囊相授，也真的很享受每一堂课”。当然，每门课程结束收集学生们的建议也是多年的习惯，只为更好地帮助同学们理解和应用计算机知识，在此感谢所有学生。

技术总结

这一年，只撰写了43篇原创技术文章，是近14年最低的一年。新开设了《AI Coding》《数字人文》《漏洞挖掘与利用》《LLM+AIGC实战》《科研成果分享》等专栏。其中，印象比较深刻的是大模型与系统安全融合的技术文章，也算是对新技术的学习和实践。未来，人工智能技术会持续发展，不知道自己是否还有精力再学习新知识和分享新技术，不再年轻，尽力就好。

恶意软件分析 (12)LLM赋能Lark工具提取XLM代码的抽象语法树
恶意软件分析 (13)LLM赋能实现基于机器学习的恶意家族分类
[LLM+AIGC] 08.零基础DeepSeek生成可视化科研图形（NapKin + ChatExcel）
[安全开源分享] Datacon24漏洞赛道冠军分享：vuln_wp —— 大模型赋能的漏洞自动化分析全解析
[AI Coding+安全] 二.CodeBuddy赋能恶意代码分析与家族分类实践
[系统安全] 六十三.Powershell恶意代码检测系列 (6) 混淆和反混淆
[系统安全] 六十四.漏洞挖掘与利用 (1)WinRAR漏洞在APT攻击中的应用总结

这一年，Github仅提交了510次，新开源了AI-Coding-iFlyCode、LLM-for-Malware、AI-Coding-CodeBuddy、DeepSeek-is-all-you-Need等项目，但更多还是记流水账。希望未来不忙的时候，能分享一些高质量的开源代码。

这一年，有幸被邀请成为了贵州省“护网”演习暨第八届贵阳大数据及网络安全精英对抗赛的裁判，也是自己第一次作为安全类比赛的裁判，与各位前辈和大佬学到了很多知识。此外，自己第五次受邀作为CSDN年度博客之星的专家评委，看到了很多年轻的分享者和新鲜的技术文章；也看到了大模型对原创技术文章的影响，AIGC是给我们带来了便利，还是危害呢？引人深思。但学习AI技术并应用于各行各业已成为趋势，使用者一定要有自己的理解和思考。

这一年，自己作为漏洞挖掘的菜鸟，从零开始学习漏洞安全知识，并获得了人生的第一个CNVD漏洞证书和编号，希望未来自己能掌握这门技术。这一年，跟着AI技术的发展，不断学习了大模型、RAG、MCP、智能体、Skill技术，从DeepSeek到CodeBuddy、iFlyCode，再到OpenClaw、Seedence 2.0，真是学无止境！

竞赛总结

这一年，作为硕导认真指导着研究生撰写论文、参与竞赛、撰写代码和开启科学研究。这一年，作为大一新生的班主任，每周的晚自习、班会、知识分享和谈心谈话，尽力让学生们适应大学的生活。这一年，作为指导老师与研究生、本科生积极讨论竞赛，申报学生的SRT项目。除夕这天下午，还有两位同学还给我发了论文最新版本和竞赛的PPT，我是该高兴呢？还是该高兴。

非常幸运，从中国国际大学生创新大赛到“挑战杯”，从中国研究生数学建模竞赛到全国大学生统计建模大赛，再到全国大学生乡村振兴大赛、全国创新创业大赛，以及学校的“四大文化工程”、博士村长等。在陈老师的带领下，我们参加了各种各样的比赛。这一年，我们竞赛获奖24项，国家级6项，省部级6项，校级12项。很多个夜晚我们都在讨论创新、选题和PPT，再忙碌的日子你们总会第一时间修改返稿。看着你们奋斗滴汗，作为老师非常开心，你们也非常给力，希望你们能珍惜这段日子。

这一年，每周都会解答陌生网友的问题，累计应该有近千次。这一年，做了好几次技术分享，与好几位博友线下面基。这一年，得到了很多很多人的帮助，也认识了很多厉害的人师。这一年，就这样离去。

再次感谢所有的同行者。微光如盏，谦以致远；知行合一，砥砺前行，感恩！

二.万家灯火中的一小盏

2025年，忙碌苦辣中又带着淡淡的酸甜。这一年，让我更加感受到了亲情的温暖，爱情的甜蜜和陪伴的重要。确实，我们都只是万家灯火中的一小盏，生活中的挫折并不可怕，但一定要勇敢，一定要热爱生活。

亲情最美

亲情是什么？是妈妈永远给孩子夹的那根冒着热气的鸡腿，是爸爸悄悄给孩子修好的玩具赛车，是老婆过年前在商场忘记自身却给丈夫买的那件红毛衣，是离家时后备箱被塞得满满当当的腊肉火腿，是一家人携手共渡难关，更是小珞小贝口中一声声的“爸爸妈妈”。当了父母之后，越发觉得没有什么比亲情和陪伴更美好，越发觉得一家人平平安安、健健康康、开开心心才是生活，才是家。

陪伴最美

这一年，即使再累再忙，每个周末都会带两个小可爱出去玩耍爬山。小朋友的笑容真的很治愈，总能给一家人带来欢声笑语，但有时候调皮得又也让人愤怒。

一月，我们看了非遗喷火和青岩古镇。二月，我们见到了雄伟的FAST大锅，在天河潭看了五彩的喀斯特溶洞。三月，镇山村、银子坡的阳光和野菜诱人，挖野菜、采泡已经成为日常。

四月，一家人去到了乌江百里画廊，船在江上行，人在画中游。五月，回到了美丽的老家施秉，可惜两个小宝高烧返程。六月，博物馆、图书馆、恐龙小镇、河滨公园都是常客，露台烧烤更是美味极了，我们小妹也周岁喽。

七月，在省外，小珞最喜欢的三星堆面具看了，七彩梦幻九寨沟看了，变脸川剧看了，火锅也吃了；在省内，水东乡的徒步走了，安顺屯堡地戏品了，外星球石头摸了，肥肠烧烤也吃了。

八月，去到关岭考古小珞和女神手都敲麻了，去到高坡看梯田和捉昆虫，回到家乡施秉终于漂了一次流。九月，小哥哥开学了，周边的各种公园徒步玩耍。

十月，国庆节一家人去泉州看海抓螃蟹，生日期间妈妈又带小珞去广州珠海长隆爽完，小朋友开心极了，这一刻，你就是最幸福的宝贝，辛苦妈妈了。可怜我小贝因为太小只能在家哼唧。

十一月，小妹大一点终于被带出来玩了，她也感受到了大自然的魅力。十二月，两小个陪伴着公园里遛弯跨年，一家人鼓励着奶奶康复，团团圆圆才是真。

这一年，非常感谢女神，她辛苦操劳着一家，感谢她付出的一切。当然，还有她作为面点师做的蛋糕，种的蔬菜，修的鲜花，小当娜名不虚传。

这一年，非常感谢父母，他们默默为这小盏灯做着一切。当然，还有小珞小贝对爷爷奶奶、公公婆婆的爱，带给我们的快乐，这就是娜璋珞贝的一家，我们的2025。

三.2026年展望

不论如何，2025已离去。希望新的一年大家都更好，都心想事成，健康快乐。

2026年，希望一家人平安健康，希望万事诸顺，多陪下父母、老婆和孩子，多些付出，一家人多出去爬山锻炼，带小贝小珞出去玩一次，最重要的是今年一家人远离生病，一家人快乐平安。

2026年，希望能中一篇一区和投一篇A，能见刊两本专著，获批两个专利，多挖两个洞，能踏实跟进项目，试试青教赛，达到评审条件，最重要的是学会放下，学会取舍，这一年技术分享还是很少。人生路，说慢也不慢，说快也不快，尽力就好。

岁末诗娴崇笃志，年终思远赋深情。
感恩这些年遇到的所有人，感谢很多读者的支持，感谢团队的帮助，感谢家人的陪伴，感谢父母的付出，感谢两个小可爱带来的快乐，最最最感谢女神的辛苦。真的很庆幸能拥有彼此，人生的另一半。

最后，感谢您的阅读。2025，微光如盏，谦以致远，万家灯火中的一小盏！

(By:Eastmount 2026-02-18 夜于贵州)

阅读原文

跳转微信打开

《AI Coding入门与实战》开源课程分享：第4课基于iFlyCode的网页开发实战（AI大学堂）

Thu, 12 Feb 2026 11:02:00 +0800

原创杨秀璋 2026-02-12 11:02 贵州

本文概述AI赋能网页开发实践，希望您喜欢！

AI大学堂官网：https://www.aidaxue.com
《AI Coding入门与实战》第1课 AI Coding概念与大模型赋能编程
《AI Coding入门与实战》第2课基于通用大模型的代码生成
《AI Coding入门与实战》第3课 iFlyCode入门与数据分析实战
《AI Coding入门与实战》第4课基于iFlyCode的网页开发实战【本博客的学习视频地址】
《AI Coding入门与实战》第5课基于iFlyCode的桌面应用程序开发
《AI Coding入门与实战》第6课基于iFlyCode的安全知识图谱构建
《AI Coding入门与实战》第7课基于iFlyCode的图书管理网站系统开发
《AI Coding入门与实战》第8课 iFlyCode智能体开发与课程总结

代码开源地址：

https://github.com/eastmountyxz/AI-Coding-iFlyCode

在生成式人工智能技术逐步进入软件工程主流程的背景下，AI Coding 已从“代码补全工具”演进为“人机协同开发范式”。本课程围绕 iFlyCode 平台，构建了一条完整的教学路径，从网页基础知识到项目级网页系统开发，系统展示了大模型如何参与结构设计、逻辑建模与交互实现，从而实现真实开发任务的自动化与智能化。课程并非单纯教授前端语法，而是强调 “需求表达—提示工程—模型生成—人机协同优化” 的现代软件开发流程，为 AI 时代的编程教学提供了方法论范式。课程目录如下：

文章目录

一.课程学习目标

1.课程概况

二.网页基础知识及HTML编程原理

1.Web开发与B/S架构
2.网页骨架——HTML
3.CSS网页样式与布局控制
4.JavaScript基本语法与交互逻辑

三.基于iFlyCode的个人网页简历制作

1.iFlyCode自动生成网页的基本流程
2.个人网页简历制作需求分析
3.基于iFlyCode的个人网页简历制作

四.基于iFlyCode的课堂抽奖网页游戏开发

1.课堂抽奖网页游戏开发基本流程
2.AI Coding制作抽奖游戏编程案例

五.基于iFlyCode的MBTI测试网页开发

1.MBTI性格测试概述
2.基于iFlyCode的MBTI测试网页开发
3.MBTI测试网页发布及部署

六.基于iFlyCode的新闻热搜网页榜单制作

1.表单与页面交互设计
2.新闻热搜网页榜单制作案例
3.新闻热搜网页发布及部署

七.基于Codex的新闻热搜网页制作拓展

1.Codex安装
2.Codex网页开发配置
3.基于Codex的新闻热搜网页榜单制作

八.课程总结与课后实践作业

一.课程学习目标

1.课程概况

本课程首先从认知层面对 AI Coding 进行界定，强调学习目标不再仅限于掌握 HTML、CSS 与 JavaScript 语法，而是培养学生将自然语言需求转化为结构化提示，并驱动大模型生成可运行系统的能力。这种能力本质上是“需求建模能力”与“提示工程能力”的融合，是未来智能软件开发者的核心素养。

课程通过多个实际案例（简历网页、抽奖系统、MBTI 测试、新闻热搜榜）构建递进式学习路径，使学生理解 AI 在不同复杂度任务中的角色转变：从静态页面结构生成，到动态交互逻辑建模，再到综合性系统开发。这种结构化设计使学习者能够逐步形成系统工程思维，而非停留在工具层面的操作技能。

二.网页基础知识及HTML编程原理

1.Web开发与B/S架构

课程首先分析 B/S（Browser/Server）架构与 C/S 架构的差异，指出 B/S 模式因其轻量化访问与标准化接口特性，成为生成式编程最适配的应用场景。浏览器作为统一运行环境，使模型生成代码具有高度可预测性和可复用性，这为大模型的代码生成提供了稳定的模式空间。

从 AI 技术角度看，B/S 架构具备高结构化、高语法规则性及高重复模式特征，这些属性与大模型的语言模式学习机制高度匹配。因此，将 Web 开发作为 AI Coding 教学起点，具有明确的技术合理性和教育可迁移性。

2.网页骨架——HTML

HTML 被定义为网页语义骨架，CSS 作为样式与布局控制层，而 JavaScript 负责行为逻辑与交互实现。在 AI Coding 环境下，大模型根据提示语同时生成三层结构代码，从而构建完整 Web 应用。学生需要理解这三层在语义与逻辑上的分工，以便通过提示语引导模型生成结构清晰、职责分明的代码。

3.CSS网页样式与布局控制

CSS 部分强调“选择器—属性—属性值”的样式控制机制，展示了样式控制在视觉设计中的作用。课程指出，大模型生成的页面往往默认结构正确，但若缺乏明确样式约束，页面呈现效果较为基础。因此提示词中应包含布局方式、字体风格、颜色体系、卡片化设计等视觉描述，从而引导模型生成具备现代 UI 风格的页面。

4.JavaScript基本语法与交互逻辑

JavaScript 被定义为页面“行为层语言”。课程特别强调模型在生成 JS 代码时，需理解事件驱动机制、DOM 操作逻辑以及用户交互流程。这说明 AI Coding 不仅是静态代码生成，更涉及程序逻辑结构推理能力，是大模型“程序理解能力”的体现。

三.基于iFlyCode的个人网页简历制作

1.iFlyCode自动生成网页的基本流程

课程提出标准 AI Coding 工作流：需求理解 → 访问 iFlyCode → 构造提示词 → 代码生成 → 迭代优化 → 运行测试。这一流程实际上构成了 AI 驱动软件开发的基本方法论，与传统“编码—调试”模式形成显著对比，强调“语义表达能力”成为开发效率关键因素。

2.个人网页简历制作需求分析

该案例聚焦结构化页面生成任务。简历网页通常包含头像区、教育经历、技能表格、项目展示区等模块。课程引导学生将现实需求抽象为页面结构描述，这是大模型生成准确网页的前提条件。此环节培养的是需求抽象能力 + 结构化表达能力。

3.基于iFlyCode的个人网页简历制作

具体实现过程如下图所示：

四.基于iFlyCode的课堂抽奖网页游戏开发

1.课堂抽奖网页游戏开发基本流程

该案例引入动态逻辑，实现从静态页面到交互系统的转变。课程通过 HTML 表单收集学生名单，利用 JavaScript 将数据存储为数组，并通过 Math.random() 生成随机索引完成抽奖功能。此过程展示了 AI 在算法逻辑生成方面的能力。

2.AI Coding制作抽奖游戏编程案例

与简历网页不同，本案例要求模型理解行为流程与事件驱动机制。学生在提示设计中需描述逻辑步骤，而模型据此生成完整脚本代码。

五.基于iFlyCode的MBTI测试网页开发

1.MBTI性格测试概述

该案例涉及多维数据处理，课程设计题目数组与维度标签，并构建计分逻辑，实现性格类型推断。学生通过提示语描述心理模型的程序化映射，使模型生成复杂逻辑系统。

2.基于iFlyCode的MBTI测试网页开发

此外，课程指出生成长代码时可能出现中断问题，并建议分文件生成。这一环节让学生认识到 AI Coding 仍需工程调优，人机协同仍然是核心模式。

3.MBTI测试网页发布及部署

部署包括本地部署和云端部署。

六.基于iFlyCode的新闻热搜网页榜单制作

1.表单与页面交互设计

本节内容的核心并非单纯的前端页面排版，而是引导学习者理解“数据驱动型网页”的交互逻辑结构。新闻热搜榜单页面属于典型的信息聚合型 Web 应用，其本质是以“结构化信息呈现”为中心的 UI—数据双层架构。课程通过 iFlyCode 的提示工程实践，将页面划分为多个功能模块：头部检索区、热榜展示区、侧栏数据辅助区与表单交互区。该结构符合现代 Web 信息系统的分层设计思想，即表现层（HTML/CSS）、交互层（JavaScript）、数据描述层（JSON/结构化数据）。

2.新闻热搜网页榜单制作案例

本节展示了一个高复杂度提示词案例，其教学价值在于让学生理解复杂前端工程可以通过结构化提示拆解为功能子模块。提示词要求网页具备响应式布局、SEO 元标签、Open Graph、可访问性标签（alt/aria）、卡片式设计、动效控制等功能。iFlyCode 通过企业版星火 X1 模型完成长文本理解与多文件代码生成，体现了大模型在“多约束条件下代码一致性生成”的能力。

3.新闻热搜网页发布及部署

本节从软件工程视角将生成的网页系统纳入“部署生命周期”。课程强调本地 Apache 部署与云服务器 Docker 部署两种模式，反映了传统 LAMP/WAMP 模型与现代容器化部署的并行存在。这一部分的教学目标并非服务器运维，而是帮助学习者理解网页应用从代码到可访问服务的技术路径。端口配置、HTTP 服务、权限管理等内容，构成 Web 系统运行的基础设施知识。

更重要的是，该部分隐含了“AI 生成代码的可运行性验证”这一概念。学生通过部署过程理解到：代码生成只是开发流程的一环，真正的工程能力体现在调试、部署、访问控制与系统适配等环节。课程最后提出“如何实现跨终端自适应页面”的问题，指向响应式设计（Media Query、弹性布局）的前端核心思想，体现课程从工具使用逐步过渡到系统性理解的教学逻辑。

七.基于Codex的新闻热搜网页制作拓展

1.Codex安装

本课程对比了 iFlyCode（星火模型体系）与 Codex（OpenAI 代码模型），说明不同模型在生态环境、插件体系和集成方式上的差异。通过 GitHub 认证与 VS Code 插件两种方式接入 Codex。

2.Codex网页开发配置

本节展示了 Codex 在 GitHub 仓库环境下的开发流程，强调“仓库选择—提示词输入—代码生成—Pull Request”的完整闭环。与 iFlyCode 本地生成不同，Codex 更强调云端代码协同与版本控制机制，这使得 AI Coding 与现代 DevOps 工作流发生融合。课程借此引入“模型作为协作成员”的概念，即 AI 不仅是工具，更是参与代码提交的协作者。

3.基于Codex的新闻热搜网页榜单制作

该部分通过复现“新闻热搜榜单”案例，实现 iFlyCode 与 Codex 在同一任务上的能力对比。教学重点在于让学生观察不同模型在代码结构组织、样式一致性、交互完整性方面的差异，从而建立“模型评估意识”。课程通过效果预览说明，AI Coding 的质量不仅取决于提示词，还与模型的训练目标、推理策略和上下文处理能力密切相关。

八.课程总结与课后实践作业

本课程系统展示了 AI Coding 从基础网页结构生成到综合 Web 系统开发的完整路径，构建了“提示工程—代码生成—工程部署”的现代软件开发教学模式，为 AI 时代编程教育提供了实践范式。课程总结如下：

网页开发基本概念及内容回顾
HTML、CSS、JavaScript基础语法
基于iFlyCode的个人网页简历制作
基于iFlyCode的课堂抽奖网页游戏开发
基于iFlyCode的MBTI测试网页开发
基于iFlyCode的新闻热搜网页榜单制作

科大讯飞的AI大学堂开源视频地址，强烈推荐大家去学习。

《AI Coding入门与实战》第4课基于iFlyCode的网页开发实战

本课程的开源实践（GitHub: AI-Coding-iFlyCode）为后续教学与研究提供了宝贵的资产。

https://github.com/eastmountyxz/AI-Coding-iFlyCode

本次课程的作业如下：

课程作业1：请了解网页开发基本概念及HTML编程的基本用法。
课程作业2：请结合自身教育专业技能情况，利用iFlyCode生成个人的网页简历。
课程作业3：请利用iFlyCode开发MBTI测试网页，并对自己的性格进行简单测试。
课程作业4：请利用iFlyCode实现爆火种草小红书的文案网页自动生成，并部署到云服务上。

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

(By:Eastmount 2026-02-12 周四写于贵阳)

阅读原文

跳转微信打开

《AI Coding入门与实战》开源课程分享：第3课 iFlyCode入门与数据分析实战（AI大学堂）

Tue, 10 Feb 2026 17:18:00 +0800

原创杨秀璋 2026-02-10 17:18 贵州

iFlyCode赋能编程入门与数据分析实战，希望对您有帮助！

AI大学堂官网：https://www.aidaxue.com
《AI Coding入门与实战》第1课 AI Coding概念与大模型赋能编程
《AI Coding入门与实战》第2课基于通用大模型的代码生成
《AI Coding入门与实战》第3课 iFlyCode入门与数据分析实战【本博客的学习视频地址】
《AI Coding入门与实战》第4课基于iFlyCode的网页开发实战
《AI Coding入门与实战》第5课基于iFlyCode的桌面应用程序开发
《AI Coding入门与实战》第6课基于iFlyCode的安全知识图谱构建
《AI Coding入门与实战》第7课基于iFlyCode的图书管理网站系统开发
《AI Coding入门与实战》第8课 iFlyCode智能体开发与课程总结

代码开源地址：

https://github.com/eastmountyxz/AI-Coding-iFlyCode

在人工智能赋能软件开发（AI Coding）快速发展的背景下，编程方式正在从“人工编写”为主逐步转向“人机协同生成”。本课程第3课围绕 iFlyCode 智能编程助手，系统展示大模型在数据分析建模、可视化生成、机器学习任务构建以及网络安全检测中的应用路径，体现了“模型即生产力”的新型开发范式。课程强调理论认知与工程实践并重，形成“工具能力 + 数据分析能力 + AI建模能力”三位一体的训练体系。课程材料来源于AI大学堂开源教学内容，课程目录如下：

文章目录:

一.数据分析基本概念及内容回顾

1.课程概况
2.什么是数据分析
3.常用数据分析库

二.iFlyCode基本功能及用法

1.什么是iFlyCode
2.iFlyCode安装及登录
3.代码解释与行间注释
4.对话交互与代码解释
5.代码优化与单元测试

三.基于iFlyCode的可视化分析代码生成

1.HTML 统计可视化生成
2.Python 关系图谱生成

四.基于iFlyCode的鸢尾花回归聚类分类分析

1.回归分析代码生成
2.聚类分析代码生成
3.随机森林分类分析代码生成

五.基于iFlyCode的网络入侵智能检测器构建

1.网络入侵检测
2.NSL-KDD 数据集描述
3.数据预处理
4.基于随机森林的网络入侵检测器构建
5.基于深度学习的网络入侵检测器构建

七.课程总结与课后实践作业

一.数据分析基本概念及内容回顾

1.课程概况

第3次课的核心目标在于引导学习者掌握 iFlyCode 驱动的 AI 编程流程，理解大模型在程序生成与智能分析中的作用机理。从工程角度看，iFlyCode 通过“提示词 → 代码生成 → 迭代优化”的闭环模式，显著降低编程门槛，提高开发效率。从方法论角度，课程强调将数据分析任务结构化为标准流程，使大模型能够在明确语义约束下生成可执行、可解释、可优化的代码。

该课程同时强化学生对 AI Coding 工具在不同任务中的适配能力，包括可视化分析、回归预测、聚类发现、分类识别以及网络入侵检测等多种典型场景，从而构建跨领域的智能开发能力。

2.什么是数据分析

课程回顾了标准数据分析生命周期：数据采集 → 数据预处理 → 探索性分析 → 建模 → 评估 → 可视化表达。这一流程的本质是将现实问题转化为可计算结构，再通过算法建模提取规律。在AI Coding环境下，该流程被重构为“任务语义描述驱动的代码自动生成链”，使分析流程从“手工实现”转向“模型辅助构建”。

3.常用数据分析库

数据分析库的引入（如 Numpy、Pandas、Matplotlib、Scikit-learn）不仅构成工具基础，也为大模型生成代码提供语义锚点，使模型输出更具可执行性。

二.iFlyCode基本功能及用法

1.什么是iFlyCode

iFlyCode 是基于讯飞星火认知大模型的智能编程插件，支持代码生成、代码解释、优化、单元测试等功能，体现了大模型在软件工程中的嵌入式应用模式。其本质属于 “编程认知增强系统”，通过自然语言理解实现代码层面的智能补全与推理。其支持 VSCode 和 IntelliJ IDEA，形成 IDE 内嵌式人机协同开发环境。

2.iFlyCode安装及登录

其安装过程如下图所示：

3.代码解释与行间注释

该功能体现了大模型在程序语义理解方面的能力。通过对 KMeans 代码的解释与逐行注释，学习者能够理解算法逻辑、参数含义及执行流程。这种“代码可解释生成”能力对于初学者构建算法认知至关重要。

4.对话交互与代码解释

对话模式允许开发者进行“语义级调试”，通过自然语言描述需求或错误现象，模型生成优化代码或修复建议。这种方式将传统 Debug 过程转化为“知识推理过程”，提高问题定位效率。

5.代码优化与单元测试

iFlyCode 支持自动生成测试用例，使代码质量控制前移至生成阶段。课程强调利用大模型分析 ValueError 等异常，通过语义对齐定位特征维度错误，实现“生成—验证—修复”的闭环开发模式。

三.基于iFlyCode的可视化分析代码生成

1.HTML 统计可视化生成

通过提示词驱动生成 HTML+JS 趋势图代码，实现编程语言热度可视化。此过程体现了 “自然语言到前端代码”的跨模态生成能力。课程强调提示词优化对代码可运行性的影响，展示了大模型生成代码的可控性问题及解决方案。

2.Python 关系图谱生成

通过 Networkx 库构建李白人物关系图谱，展示大模型在图结构建模与可视化表达中的应用。这一过程体现了语义信息向结构化网络表达的转换能力，是知识图谱可视化的典型实践。

四.基于iFlyCode的鸢尾花回归聚类分类分析

1.回归分析代码生成

课程利用线性回归模型建立花瓣宽度与长度之间的函数关系，强调模型解释性与拟合可视化的重要性。

2.聚类分析代码生成

通过聚类发现数据内在结构，展示无监督学习在模式发现中的作用。

3.随机森林分类分析代码生成

课程展示监督学习模型构建流程，并通过混淆矩阵评估模型性能。

课程同时引入错误调试案例，强调大模型辅助 Debug 的工程价值。

五.基于iFlyCode的网络入侵智能检测器构建

1.网络入侵检测

首先介绍网络入侵检测的基本流程，包括数据采集、特征工程、建模识别等步骤，强调数据安全分析的系统性。

2.NSL-KDD 数据集描述

说明该数据集在入侵检测研究中的标准地位及类别划分。

3.数据预处理

课程利用大模型生成 Python 预处理代码，实现 One-Hot 编码、标准化等操作，体现大模型在数据工程阶段的预处理应用。

4.基于随机森林的网络入侵检测器构建

构建基于传统机器学习的检测器，并评估性能。

5.基于深度学习的网络入侵检测器构建

展示深度学习在入侵检测中的应用，强调 CNN 的局部特征提取与 BiLSTM 的序列建模能力。

七.课程总结与课后实践作业

本课程通过 iFlyCode 展示了 AI Coding 的完整实践路径，体现了大模型在编程教育、数据科学和网络安全领域的赋能能力。学习者不仅掌握工具操作，更建立了“语义驱动开发”的认知模式，为未来智能软件工程奠定基础。

《AI Coding入门与实战》第3课 iFlyCode入门与数据分析实战

本课程开源实践（GitHub: AI-Coding-iFlyCode）为后续教学与研究提供宝贵的资产。

https://github.com/eastmountyxz/AI-Coding-iFlyCode

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

(By:Eastmount 2026-02-09 周一写于贵阳)

阅读原文

跳转微信打开

[AI安全论文] (48)TIFS24 基于注意力的恶意软件API定位技术

Mon, 09 Feb 2026 10:39:00 +0800

原创 Eastmount & LI 2026-02-09 10:39 贵州

本文介绍恶意软件APIP定义技术，希望对您有所帮助！

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

前一篇博客介绍了一种LLM上下文驱动的Android恶意软件检测框架。本文将介绍APILI，一种面向恶意软件行为分析的深度学习方法，用于在动态执行轨迹中定位与恶意攻击技术（MITRE ATT&CK Techniques）相对应的底层 API 调用。实验结果表明 APILI 在技术发现与 API 定位两方面均优于传统方法与现有机器学习模型，显著降低分析负担。注意，由于我们团队还在不断成长和学习中，写得不好的地方还请海涵，希望这篇文章对您有所帮助，这些大佬真值得我们学习。fighting！

文章目录

一.摘要
二.研究动机与贡献
三.背景和挑战
四.模型设计

1.技术发现机制
2.系统总体结构
3.API Call表示学习
4.技术语义表示
5.资源注意力机制
6.技术注意力机制
7.损失函数设计
8.API 调用定位机制

五.实证研究

1.实验设置
2.实现细节
3.实验评估

六.讨论与结论

原文作者：Guo-Wei Wong , Yi-Ting Huang , Ying-Ren Guo , Yeali Sun, and Meng Chang Chen
原文标题：Attention-Based API Locating for Malware Techniques
原文链接：https://ieeexplore.ieee.org/document/10309174
发表期刊：IEEE TIFS 2024
其它开源代码：https://github.com/Irish-kw/Attention-Based-API-Locating-for-Malware-Techniques

一.摘要

传统恶意软件分析难以将底层API调用与高层恶意技术直接关联，导致分析效率低下。本文提出 APILI（API LocatIng System），一种面向行为型恶意软件分析的深度学习框架，用于在动态执行轨迹中定位与已发现恶意技术相对应的 API 调用。

APILI 在 API 调用、系统资源以及攻击技术三者之间构建多重注意力机制，并将 MITRE ATT&CK 框架中的战术、技术及过程知识嵌入神经网络结构中。
方法采用微调 BERT 进行参数/资源语义嵌入，利用奇异值分解（SVD）构建技术表示空间，并设计层级结构与噪声增强机制以提升 API 定位能力。

据作者所述，这是首个能够将高层恶意技术语义与低层 API 调用行为证据进行自动对齐的深度学习方法。实验表明，APILI 在技术识别与 API 定位两项任务中均优于传统规则系统及其他机器学习方法，显著降低了分析人员的工作负担。

二.研究动机与贡献

论文首先指出网络威胁情报知识库（如 MITRE ATT&CK）虽提供标准化的攻击技术描述，但这些描述停留在语义层级，并不包含对应的具体系统执行证据，如 API 调用或审计日志事件。相反，恶意行为的真实体现存在于动态执行轨迹中的 API 调用序列及其参数资源。这种“高层技术语义”与“低层系统行为证据”之间的抽象差异构成了严重的语义鸿沟，使得安全分析仍依赖人工规则或专家经验建立映射，既难扩展又易误报。论文将这一问题界定为API Locating Problem，即从高层 ATT&CK 技术反向定位其底层实现 API。

作者强调，ATT&CK 技术具有精确定义的攻击语义，可作为恶意行为分析的中间语义层。传统系统（如 Holmes、RapSheet）通过手工规则实现跨层映射，但规则构建成本高且难以适应攻击变种。论文动机在于设计一种无需专家知识、通过表示学习自动建模“技术-资源-API”因果依赖的深度学习框架。该框架不仅能够发现恶意技术，还能直接定位关键 API 调用，从而建立跨层行为解释链。

本文的核心贡献在于提出了一个跨层注意力传播模型，实现 API 行为、资源对象与攻击技术三层语义之间的自动对齐。首先，设计资源注意力机制以捕捉 API 调用与系统对象之间的语义依赖；其次，引入技术注意力机制并结合技术嵌入空间实现资源到 ATT&CK 技术的映射；最后，在大规模真实数据集上验证模型在技术识别与 API 定位两项任务中的显著性能优势。

三.背景和挑战

1.Cuckoo Sandbox
Cuckoo Sandbox 是常用的动态分析平台，通过虚拟环境执行恶意软件并生成 API 调用轨迹，再利用签名规则识别恶意行为。然而该系统依赖专家编写签名，维护成本高，且难以覆盖 API 与 ATT&CK 技术之间复杂的多对多关系。本文仅将 Cuckoo 作为轨迹采集工具，而将语义建模任务交由深度模型完成。

2.Dynamic Malware Analysis
动态分析产生的执行轨迹具有层级结构，包括进程树、API 调用序列及其参数。API 调用在本文被视为最小行为单元，由类别、函数名和参数组成，其中参数对应被操作的系统资源（文件、注册表、进程等）。论文指出恶意行为与 API 调用存在强相关性，参数语义尤为关键，因此需要对参数进行语义嵌入以保留行为含义。

execution trace
process tree
Process
API call

3.MITRE ATT&CK Framework
ATT&CK 提供战术、技术与过程的结构化攻击知识体系。技术在本文中作为恶意行为的语义标签，每种技术可能由一个或多个 API 调用实现，且可能分散在不同时间或进程中，呈现明显的多对多映射。这种复杂关系使规则匹配难以奏效，成为模型设计核心挑战。

tactic
technique/sub-technique
procedure

4.Deep Learning
论文借鉴自然语言处理中的嵌入与注意力机制，将 API 调用视为“句子”，将参数视为“词语”。BERT 用于生成参数上下文语义表示，而注意力机制用于识别与特定技术最相关的资源与 API，从而在序列中选择关键行为证据。

5.Motivation and Key Challenges
核心挑战包括进程与 API 数量可变、技术相关实体识别困难，以及合法行为与恶意行为的混淆问题。尤其是 API 与技术之间的多对多关系，使单次规则匹配不可行。APILI 通过多层注意力传播建模资源因果流，降低误报并实现跨层语义对齐。

Variable numbers of processes and API calls
Identification of technique relevant entities
Resource correlation for false positive reduction

四.模型设计

本节对 APILI 系统、神经网络模型以及 API 调用定位方法进行总体概述。在模型训练之前，首先进行两个预处理步骤：API 调用嵌入表示和攻击技术表示学习。APILI 模型的高层结构如图 2 所示。该模型以恶意软件样本的动态行为作为输入，这些行为由 Cuckoo 沙箱记录。为支持攻击技术发现与 API 调用定位，APILI 引入了两种注意力机制：资源注意力（resource attention）和技术注意力（technique attention）。

左支路：API调用语义分支
右支路：API调用行为分支
中间融合：注意力机制定位技术

1.技术发现机制

该部分将恶意技术识别形式化为多标签分类问题。论文假设一个恶意样本可产生多个进程，而每个进程可能对应不同 ATT&CK 技术集合，因此以进程为基本分析单元进行建模。这种设计避免了跨进程语义干扰，使技术识别更加精细化。模型使用二元相关（Binary Relevance, BR）策略，将多标签任务拆解为多个独立二分类子任务，每个技术对应一个分类器，从而实现对技术存在性的概率建模。

技术预测基于公式(1)完成。模型先对每个进程计算技术概率，再进行样本级聚合，只要任一进程满足阈值条件即判定该技术存在。这一设计反映了恶意行为的“局部触发即可整体成立”的特征，符合攻击技术在实际执行中的分布式实现模式。该阶段的输出不仅用于技术发现，还为后续 API 定位提供监督信号，是 APILI 整体推理链条的起点。

2.系统总体结构

图2展示了 APILI 的核心结构，该模型由两类注意力机制构成：资源注意力（Resource Attention）与技术注意力（Technique Attention），分别用于刻画“API→资源”与“资源→技术”的双层语义映射。这种层级式注意力设计体现了因果链式建模思想，即先建立底层操作与系统资源之间的关联，再推理资源与高层攻击技术之间的联系。

系统前置两个冻结预处理模块：

API 嵌入模块
技术表示模块

这种“预训练 + 端到端训练”的混合架构在保证语义表达能力的同时降低了训练复杂度。整个模型从输入动态执行轨迹到输出技术概率与 API 定位结果形成闭环，实现从行为表征到因果定位的自动化推理流程，是本研究的核心创新框架。

3.API Call表示学习

API 调用被视为“类自然语言句子”，其语义由类别、函数名及参数共同构成。论文采用微调 BERT对字符串参数进行语义编码，这一选择优于传统 Doc2vec 的原因在于：BERT 能捕捉上下文语义依赖，并通过 WordPiece 机制有效表示 CLSID 等稀有符号，从而提升对恶意行为关键参数的表达能力。

编码流程中，参数向量经 AutoEncoder 压缩为低维表示，再与类别和函数名嵌入拼接形成 API 向量。这种结构保持了 API 语义完整性，同时避免高维噪声干扰。该嵌入是整个模型后续注意力计算的基础，其质量直接影响技术发现与资源定位的准确性。此设计体现了“语义保真优先于结构简化”的建模原则。

本研究将改用微调后的BERT把API调用的字符串实参映射成768维向量。BERT是动态嵌入，同一词在不同上下文里向量不同，Doc2vec是静态的，一词一向量。实参里常出现罕见词（如 COM 类 CLSID），Doc2vec 直接当 OOV 扔掉；BERT 的 30 k WordPiece 子词表能把罕见词拆成子词，依旧生成可用向量。

4.技术语义表示

ATT&CK 技术之间存在共现与组合关系，论文构建技术共现矩阵并通过 SVD/PCA降维得到技术表示 λ。该表示反映技术之间的语义相关性，使模型具备对“技术协同出现模式”的理解能力，而不仅依赖单点标签监督。

这一模块等价于构建攻击技术的“潜在语义空间”。技术注意力后续利用该表示计算资源—技术相关性，从而实现从底层资源行为到高层攻击策略的映射。该方法避免了人工规则维护，是 APILI 脱离专家规则的重要步骤。

攻击模式是多技术组合，ATT&CK技术与API调用之间存在强相关性，用“技术”比直接用原始API更能表达“攻击意图”，于是建了一张样本-技术共现矩阵（行 = 恶意软件样本，列 = 技术，值 = 是否出现），矩阵巨大且稀疏，需要降维同时保留语义。选用SVD或PCA是将大矩阵拆成“低维特征向量”，每行样本得到一条紧凑向量，后续可直接喂给分类器或注意力模块。

5.资源注意力机制

该机制首先通过 Bi-GRU 建模 API 调用序列的时序依赖，获得隐藏状态 hn。随后提取所有唯一参数作为资源集合 rn，并计算 API 参数向量与资源向量的余弦相似度，形成资源注意力权重矩阵 rw。这一矩阵刻画“哪些 API 操作与哪些系统资源高度相关”。

资源向量 rv=hn×rw 是后续技术推理的关键中间表示。资源注意力不仅用于 API 定位，也为技术发现提供资源上下文。其本质是一个因果线索提取层，强调资源在攻击行为中的核心地位。该设计显著降低了误报，因为它引入资源间信息流依赖，而非孤立行为判断。

6.技术注意力机制

技术注意力以资源向量为输入，与技术表示 λ 进行线性映射后加入噪声并经 softmax 归一化，得到技术注意力 dw。噪声注入用于打破相同注意力值导致的分区问题，提高模型泛化性与排序区分能力。

随后通过递归层归一化（LayerNorm）迭代更新资源向量，实现多层语义传播。这一多层注意力传播机制使模型能够捕捉跨资源、跨技术的复杂依赖关系，等价于在技术空间进行图传播。该部分体现了 APILI 从单跳相关推理扩展到多跳因果推理的能力，是性能提升的关键因素。

7.损失函数设计

模型目标由两部分组成：

一是 Binary Cross Entropy 用于技术分类；
二是 Resource Distance Loss 用于最大化真实资源的注意力权重。

资源距离损失迫使模型在技术预测前优先校准资源注意力，使技术预测依赖于正确的因果资源，而非噪声信号。最终联合损失函数形成端到端优化目标。这种“先因果对齐、再语义分类”的设计使模型同时具备高技术识别率和高 API 定位精度。

8.API 调用定位机制

模型训练完成后，技术注意力排序得到 TOP-K 关键资源，再利用资源注意力矩阵定位对应参数及 API 调用。由于资源与 API 参数在查找表中存在映射关系，整个定位过程可自动完成，无需人工规则。API定位的意义在于不需要人工去一条条看API调用，而是直接告诉哪些API可能和某个恶意行为有关。

评价指标包括 Relevance、TOP-K、MAP-K、MRR，体现资源排序质量。该阶段证明 APILI 能从高层技术反向推理到底层 API，实现“技术→资源→API”的可解释因果链路，这是该论文区别于传统恶意检测工作的核心突破。

APILI模型通过两个注意力机制来完成API定位：

技术注意力：判断某个技术与哪些系统资源最相关，输出的是一个注意力向量，表示每个资源对该技术的重要性。
资源注意力：判断某个资源是哪些API调用操作的，输出的是另一个注意力向量，表示每个API对该资源的操作强度。

API定位的流程：

预测技术：用训练好的模型预测出该样本中存在的所有技术
提取注意力矩阵：从模型中提取技术注意力矩阵和资源注意力矩阵
排序资源：对每个技术，按技术注意力值从高到低排序，选出TOP-K个最相关的资源
排序API：从选中的资源中，按资源注意力值排序，找出操作这些资源的API调用
查找API调用：通过查找表将资源映射回原始的API调用，完成定位

五.实证研究

1.实验设置

实验部分首先明确了评估环境与数据来源。所有实验均基于 Cuckoo Sandbox 动态分析日志构建 API 调用序列，样本涵盖多种恶意软件家族，保证行为技术覆盖面。为确保评估客观性，作者采用训练集、验证集、测试集分离策略，并对不同攻击技术类别保持分布平衡。数据预处理阶段包含 API 标准化、去噪、序列截断与填充操作，使模型输入维度统一，同时保留关键行为顺序信息。

从实验结构上看，APILI 的评估分为“技术发现能力”和“API 定位能力”两个核心任务，分别对应技术级别识别性能与行为级别定位精度。这种双层评估框架体现了论文研究目标——不仅识别恶意技术类别，还需定位其在行为序列中的具体 API 来源，从而提升安全可解释性。

论文采用多维度指标体系以全面反映模型性能。技术发现任务主要使用 Precision、Recall、F1-score；API 定位任务额外引入 Localization Accuracy。其中，F1-score 用于衡量模型在类别识别中的综合能力，而定位准确率衡量模型是否正确识别技术对应的关键 API 调用点。实验分析包含15202个样本的数据集，对APILI进行了全面评估。

将APILI与其他七种机器学习方法以及两种深度学习模型进行了性能比较
使用TOP-K评分，MAP-K评分和MRR来衡量API定位性能对API调用预测的准确性
为深入了解APILI中每个单独成分的贡献，进行了消融研究
提高了一个详细案例研究，证明APILI的实用性，案例研究真是了APILI如何在真实场景中有效找到系统资源和相应的API调用。

2.实现细节

模型实现基于 PyTorch 框架，采用 Adam 优化器与交叉熵损失函数。训练过程中引入 dropout 与早停策略以防止过拟合。嵌入层采用 API 调用语义嵌入与技术标签嵌入的联合表示。训练批次大小与学习率经过网格搜索优化，以达到最佳收敛状态。

从效率结果图可以观察到，APILI 在增加双注意力机制后训练时间增长有限，而推理阶段延迟仍维持在可接受范围。这说明模型在复杂语义建模与运行效率之间取得了良好平衡。

3.实验评估

Technique Discovery
技术发现任务的实验结果如表 6 所示。APILI 在所有技术类别上的 F1-score 均高于对比模型，尤其在复杂技术（如多阶段攻击链）上的 Recall 提升明显。该结果表明，模型能够捕捉长距离依赖，避免传统模型因序列过长导致语义稀释的问题。

API Locating
API 定位实验结果（表 7）显示，APILI 在定位准确率方面大幅领先基线模型。特别是在长序列样本中，其性能下降幅度最小。这说明资源注意力机制有效解决了“多进程多资源依赖”的复杂行为链问题。

图 4 展示了模型在一个真实样本中的 API 定位热力图。可以观察到模型对攻击关键 API 调用分配了显著更高权重，而对无关调用权重较低。这种可解释性增强了模型在安全取证场景中的应用价值。

Ablation Study
消融实验（表 8）验证了模型组件的重要性。去除资源注意力后，误报率显著上升；去除技术注意力后，Recall 明显下降。这说明两种注意力机制分别承担“行为因果建模”与“技术语义对齐”的关键角色。

表11和案例分析图（图4）展示了 APILI 在真实恶意样本中的技术识别与 API 定位结果。模型成功识别出多个相关 API 并将其映射至对应攻击技术。该结果证明模型不仅能输出分类标签，还能提供攻击链级别的解释。

六.讨论与结论

本文提出了一种基于注意力的恶意软件行为分析机制APILI，用于自动识别MITRE ATT和CK技术及其对应的API调用。

第一阶段：训练一个具有资源注意力输出的BiGRU，以发现API调用和被操纵的系统资源之间的关系。
第二阶段：使用所提出的技术注意来探索资源和技术之间的关系。

传统的动态恶意软件分析工具需要大量的人力来构建知识并分析恶意软件样本的恶意行为。我们的系统减少了分析人员发现恶意行为和对可疑系统资源进行排序的工作量。我们使用了Cuckoo Sandbox，用于恶意软件分析以记录API跟踪，使用API调用嵌入和技术表示来构造领域知识和进行威胁推理，对APILI的实验评估表明，能够准确识别恶意行为及其对应的API调用，包括技术和API调用之间的一对多和多对多映射。

结论：APILI的优势在于减少了专家手动定位基于签名的系统无法推断的API调用的需要，这是第一次尝试使用深度学习方法来定位与发现高质量的数据

未来展望：将考虑将该技术应用于审计日志，与API定位类似，将一项技术与审计日志的一个或多个事件相关联，极大帮助识别隐形攻击。

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

(By:Eastmount 2026-02-09 周一夜于贵阳)

前文推荐：

阅读原文

跳转微信打开

《AI Coding入门与实战》开源课程分享：第2课基于通用大模型的代码生成（AI大学堂）

Tue, 03 Feb 2026 13:06:00 +0800

原创杨秀璋 2026-02-03 13:06 贵州

基于通用大模型的代码生成课程，希望您喜欢！

AI大学堂官网：https://www.aidaxue.com
《AI Coding入门与实战》第1课 AI Coding概念与大模型赋能编程
《AI Coding入门与实战》第2课基于通用大模型的代码生成【本博客的学习视频地址】
《AI Coding入门与实战》第3课 iFlyCode入门与数据分析实战
《AI Coding入门与实战》第4课基于iFlyCode的网页开发实战
《AI Coding入门与实战》第5课基于iFlyCode的桌面应用程序开发
《AI Coding入门与实战》第6课基于iFlyCode的安全知识图谱构建
《AI Coding入门与实战》第7课基于iFlyCode的图书管理网站系统开发
《AI Coding入门与实战》第8课 iFlyCode智能体开发与课程总结

代码开源地址：

https://github.com/eastmountyxz/AI-Coding-iFlyCode

当前，传统以语法驱动为核心的开发模式，逐步向以语义理解与人机协作为特征的智能编程范式演进。本课程是AI大学堂开源系列课程《AI Coding入门与实战》的第二课，聚焦于通用大模型在代码生成任务中的方法论与实践应用。课程通过结构化教学，从编程基础到复杂分析任务，完整呈现了如何利用国产大模型（如讯飞星火、DeepSeek）作为智能编程助手，实现从需求理解到代码生成、调试优化的全流程。本文旨在为AI辅助编程的教学与实践提供一套可复用的学术框架与案例参考。课程目录如下：

文章目录

一.通用大模型制作网页版个人简历

1.课程概况
2.通用大模型制作网页版个人简历——讯飞星火

二.Python编程语言的基本用法

1.Python基本概念及优势
2.Python基础语法
3.条件语句和循环语句
4.函数和文件操作
5.常用AI库及课程推荐

三.数据分析基本概念

1.什么是数据分析
2.数据分析Coding及应用

四.基于讯飞星火的可视化分析代码生成

1.思维导图可视化
2.流程图可视化
3.HTML统计报表可视化
4.Python关系图谱可视化

五.基于讯飞星火的鸢尾花回归聚类分类分析

1.回归分析代码生成
2.聚类分析代码生成
3.SVM分类分析代码生成

六.基于DeepSeek的文本挖掘AI Coding

1.数据预处理及词云可视化分析
2.评论LDA主题挖掘代码生成
3.基于机器学习的情感分析代码生成
4.基于CNN-BiLSTM的情感分析代码生成

七.课程总结与课后实践作业

一.通用大模型制作网页版个人简历

1.课程概况

第2次课《基于通用大模型的代码生成》，旨在利用通用大模型开启AI Coding之旅，通过易于上手且更熟悉的通用大模型让大家了解AI Coding背后的原理及基本用法。课程首先通过上一次课的作业带领大家了解网页代码生成过程，再详细剖析数据分析及机器学习代码生成案例。

2.通用大模型制作网页版个人简历——讯飞星火

该案例展示了生成式模型在结构化网页开发中的可控应用。通过规范化提示词（包括基本信息、教育经历、科研竞赛、实践经验、专业技能等要素），大模型可自动生成HTML网页代码。此过程体现了提示工程对生成质量与可解释性的关键影响。该案例同时锻炼学生对“代码可读性、模块结构与前端布局逻辑”的审查能力。

二.Python编程语言的基本用法

尽管以AI生成为焦点，课程并未忽视编程基础的重要性。本部分系统回顾了Python作为AI开发主力语言的核心语法要素，包括变量与数据类型、控制流（条件与循环）、函数定义及文件操作。其学术价值在于阐明：扎实的语法基础是有效评估、调试与优化大模型生成代码的前提。只有理解代码的内在逻辑，开发者才能与AI进行高效“对话”，将模糊需求转化为精准的提示词，并对生成结果进行批判性检验与集成。

1.Python基本概念及优势

Python作为AI领域的核心编程语言，在科学计算、机器学习、数据挖掘等方向具有生态优势。课程强调其在大模型生成代码后的理解、调试与二次开发中的桥梁作用。

2.Python基础语法

该部分介绍变量、数据类型、输入输出、注释规范等内容。

3.条件语句和循环语句

通过if语句与for/while循环，使学生理解程序流程控制在数据分析任务中的重要性。

4.函数和文件操作

强调模块化设计思想与文件读写机制，为后续数据分析与模型训练提供技术基础。

5.常用AI库及课程推荐

常用AI库能更好地赋能大家开展AI Coding和数据分析，代表性的库包括NumPy、Pandas、SciPy、Scikit-learn、Matplotlib等。

三.数据分析基本概念

课程从科学研究的范式出发，阐释了数据分析的标准流程——从数据采集、预处理、探索性分析到建模与可视化。在此基础上，重点论述了AI Coding如何在此流程中扮演“加速器”与“创新催化剂”的角色。这一定位揭示了AI并非取代数据分析师的专业判断，而是将其从繁琐的编码中解放，更聚焦于问题定义、逻辑设计与结果阐释。

1.什么是数据分析

课程从数据采集、预处理、EDA分析、建模、验证、可视化等方面构建完整分析流程框架。该流程是后续大模型代码生成案例的理论基础。

2.数据分析Coding及应用

AI Coding赋能场景包括企业智能分析、科研数据处理、商业决策支持与医疗数据分析等领域，生成式AI在真实生产环境中的已具应用潜力。

四.基于讯飞星火的可视化分析代码生成

本模块是课程的核心实践环节，通过四个由浅入深的案例，全景式展示了代码生成的多样性与递进性。

1.思维导图可视化

该案例展示大模型对结构化知识的表达能力，实现ATT&CK知识的可视化呈现。

2.流程图可视化

该案例说明大模型在算法流程图自动构建方面的应用价值。

3.HTML统计报表可视化

结合前端技术生成交互式数据报表，体现AI Coding在BI可视化中的实用性。

4.Python关系图谱可视化

利用NetworkX库实现人物关系网络建模，展现大模型对复杂数据结构建模的支持。

五.基于讯飞星火的鸢尾花回归聚类分类分析

本案例选择经典鸢尾花数据集，完整演示了AI生成标准机器学习代码的能力。

回归分析：生成线性回归模型，预测花瓣长度与宽度的关系，并输出拟合方程与评估指标。
聚类分析：生成K-Means聚类代码，可视化簇分布与中心点。
分类分析：生成支持向量机（SVM）分类代码，并完成模型评估。

该案例证明了通用大模型能够准确调用Scikit-learn等主流库API，遵循机器学习建模的标准流程，为快速原型构建提供了强大支持。

1.回归分析代码生成

该部分将构建花瓣宽度与长度之间的回归关系，体现模型拟合与统计解释能力。

2.聚类分析代码生成

该案例实现无监督学习任务，展示聚类结果的可视化表达。

3.SVM分类分析代码生成

该部分完成多类别分类任务并输出评估指标，说明监督学习流程。

六.基于DeepSeek的文本挖掘AI Coding

本模块聚焦于更复杂的自然语言处理任务，展示了AI在文本分析全链条中的应用。

1.数据预处理及词云可视化分析

以“贵州黄果树瀑布旅游评论”为例，生成包括数据读取、中文分词（Jieba）、停用词过滤与词云图生成的完整代码。重点探讨了如何通过提示词工程引导模型处理中文文本的特殊性，并引出对生成结果中“中性词过多”等典型问题的优化思考。

2.评论LDA主题挖掘代码生成

案例引导大模型生成LDA模型的实现代码，用于从评论数据中自动发现潜在主题。这体现了大模型对非监督学习复杂算法的理解与实现能力。

3.基于机器学习的情感分析代码生成

该案例生成了基于TF-IDF特征与朴素贝叶斯分类器的情感分析代码。

4.基于CNN-BiLSTM的情感分析代码生成

该案例介绍如何生成基于CNN-BiLSTM混合神经网络的分类模型代码。通过对比，课程生动说明了大模型能够根据需求复杂度，提供从浅层模型到深层架构的不同技术选型与代码实现，展现了其对算法体系的知识广度与代码适配深度。

七.课程总结与课后实践作业

本课程通过对一系列连贯案例的学术化剖析，实证了当前通用大模型在代码生成领域已具备广泛的实用价值。课程的成功之处在于构建了一个“基础-应用-拓展”的立体教学框架，将AI Coding的核心技能“精准的需求分析、结构化的提示工程、系统性的代码评估与迭代优化”贯穿始终。总之，本课不仅是一系列技术操作指南，更是一次关于人机协同编程范式的思想启蒙。

《AI Coding入门与实战》第2课基于通用大模型的代码生成

展望未来，AI辅助编程的教育应进一步强调：

1）人类程序员的架构设计权与核心判断力不可替代；
2）提示词工程将发展为一项重要的元编程技能；
3）对生成代码的安全性、效率与可维护性的审查至关重要。

本课程的开源实践（GitHub: AI-Coding-iFlyCode）为后续教学与研究提供了宝贵的资产。

https://github.com/eastmountyxz/AI-Coding-iFlyCode

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

(By:Eastmount 2026-02-03 周二写于贵阳)

阅读原文

跳转微信打开