Power plant safety training lesson plan generation method and device based on agent and skill package, and medium

Abstract

The application relates to the technical field of power safety training and artificial intelligence, and provides a power plant safety training lesson plan generation method and device based on an agent and a skill package and a medium, which comprises the following steps: obtaining a lesson plan generation requirement, performing task planning on the requirement based on a domain constraint rule to generate a task plan; executing the corresponding skill package according to the task plan to generate an initial lesson plan; performing compliance verification on the initial lesson plan; in response to the compliance verification failing, triggering task re-planning to update the task plan and re-execute until the compliance verification passes, and outputting a target lesson plan. The application deeply embeds the domain constraint rule into the planning and verification closed loop of the agent, forms a dynamic error correction mechanism, effectively overcomes the model illusion problem, and significantly improves the compliance, accuracy and reliability of the lesson plan generation.

Description

Technical Field

[0001] This application relates to the fields of power safety training and artificial intelligence technology, specifically to a method, device, and medium for generating power plant safety training materials based on intelligent agents and skill packages. Background Technology

[0002] Currently, safety training in power plants is a fundamental task for ensuring the stable operation of power production and the safety of personnel. With the increasing complexity of power system equipment and the rising mobility of outsourced and subcontracted workers, the demand for safety training has surged, placing higher demands on the relevance, timeliness, and standardization of training content. Traditional methods of manually writing training materials require training managers to sift through massive amounts of safety knowledge, organize content, and then arrange it according to a set format. This process is time-consuming and labor-intensive, and the quality of the training materials heavily relies on the writer's personal experience and knowledge, making it difficult to guarantee standardization and optimality. In recent years, large language models have demonstrated powerful capabilities in natural language understanding and generation, providing a technological possibility for the automated generation of training materials.

[0003] However, directly applying a general-purpose language model to generate power plant safety training materials suffers from insufficient depth of professional knowledge and the problem of illusion, easily leading to factual errors or fabricated clauses in the generated content. Furthermore, the task processing lacks structured decomposition capabilities, often attempting to generate results "in one step" when faced with complex tasks, resulting in loosely structured training materials that lack focus or omission of crucial elements. In addition, the existing generation process is rigid, lacking flexible customization capabilities, unable to adapt content and adjust style according to users' natural language requirements, and exhibiting poor capability reuse and scalability; when new capabilities are added, the entire system must be modified and redeployed.

[0004] Therefore, there is an urgent need for a method to generate power plant safety training materials that can fully utilize the semantic understanding and generation capabilities of large language models, while overcoming their shortcomings such as insufficient professional depth, lack of task planning, and limited tool interaction, and achieve highly controllable, professional, accurate, and flexibly customizable results. Summary of the Invention

[0005] To address the problem that existing general-purpose language models lack compliance control and error correction capabilities in generating professional training materials, leading to factual errors and difficulty in ensuring professional accuracy, this application proposes a power plant safety training material generation method, device, and medium based on intelligent agents and skill packages. This method deeply embeds domain constraint rules into the planning and verification closed loop of the intelligent agent, forming a dynamic error correction mechanism of "planning-execution-verification-replanning," thereby improving the compliance, accuracy, and reliability of professional training material generation.

[0006] In a first aspect, the present invention provides a method for generating power plant safety training materials based on intelligent agents and skill packages, including: Obtain the lesson plan generation requirements, perform task planning based on the requirements according to the domain constraint rules, and generate a task plan; The corresponding skill packs are executed according to the task plan to generate initial lesson plans; The initial lesson plan was verified for compliance. In response to the failure of the compliance check, a task replanning is triggered to update the task plan and re-execute it until the compliance check passes, at which point the target teaching plan is output.

[0007] In an optional implementation, the domain constraint rules include at least one of regulatory tracing requirements and specific measure priority requirements.

[0008] In an optional implementation, the requirement for legal citation is that the content of the lesson plan must be associated with the corresponding source of the relevant law; The specific measures require prioritizing the retrieval of at least one of organizational measures, technical measures, and safety measures in response to the operational items involved in the requirement.

[0009] In an optional implementation, the compliance verification of the initial lesson plan includes at least one of the following dimensions: Verification of the timeliness of regulations, verification of the standardization of terminology, and verification of the completeness of content.

[0010] In an optional implementation, the timeliness verification of the regulations includes: Verify that the legal provisions cited in the initial lesson plan are the current and valid versions; In response to the existence of both new and old versions of the same regulation, only the content of the new version is retained, and the content of the old version is marked as obsolete.

[0011] In an optional implementation, the step of performing task planning based on domain constraint rules to generate a task plan includes: The requirements are semantically parsed to extract structured requirement elements; Based on the structured requirement elements and the domain constraint rules, the requirement is decomposed into a sequence of sub-tasks with dependencies, which serves as the task plan.

[0012] In an optional implementation, the abnormal conditions that trigger the task replanning include at least one of the following: The execution result of the skill pack is empty; The compliance check determined that the initial lesson plan referenced repealed regulatory provisions.

[0013] Secondly, the present invention provides a power plant safety training lesson plan generation device based on intelligent agents and skill packages, comprising: The planning module is configured to acquire lesson plan generation requirements, perform task planning based on the requirements according to domain constraint rules, and generate a task plan. The execution module is configured to schedule the execution of the corresponding skill pack according to the task plan and generate the initial lesson plan; The verification and replanning module is configured to perform compliance verification on the initial lesson plan. In response to the failure of the compliance verification, it triggers task replanning to update the task plan and re-execute it until the compliance verification passes, and then outputs the target lesson plan.

[0014] In an optional implementation, the planning module includes a task planner and a memory manager, the task planner being configured to perform the task planning and the task replanning, and the memory manager being configured to store the task plan and the initial lesson plan; The verification replanning module includes an execution controller configured to schedule the skill pack and collect execution results.

[0015] Thirdly, the present invention provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method described in any of the foregoing embodiments.

[0016] Beneficial effects: This application introduces domain constraint rules during the task planning phase, subjecting the large language model agent to deep constraints from power plant safety business regulations when breaking down the lesson plan generation task, thus ensuring the professional compliance of the generated content from the source. Simultaneously, by introducing a compliance verification mechanism and triggering task replanning to update the task plan and re-execute when verification fails, a dynamic error correction closed loop of "planning-execution-verification-replanning" is constructed. This effectively overcomes the illusion problem and factual errors that general-purpose large language models are prone to when generating content in professional domains, significantly improving the accuracy, timeliness, and system reliability of lesson plan generation.

[0017] Furthermore, by encapsulating the atomic capabilities required for lesson plan generation into pluggable skill packages, the system effectively synergizes the reasoning capabilities of large language models with the execution capabilities of specialized tools. This leverages the semantic understanding and planning capabilities of the model while compensating for its shortcomings in professional depth and tool interaction. The system also possesses excellent scalability, significantly reducing training management costs and promoting the standardization of safety training. Attached Figure Description

[0018] To more clearly illustrate the technical solutions of the embodiments of this application, the accompanying drawings used in the embodiments of this application will be briefly introduced below. It should be understood that the following drawings only show some embodiments of this application and should not be regarded as a limitation of the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 A flowchart illustrating a method for generating power plant safety training materials based on intelligent agents and skill packs, provided in this application embodiment; Figure 2 A schematic flowchart of another method for generating power plant safety training materials based on intelligent agents and skill packs, provided for an embodiment of this application; Figure 3 This is a schematic diagram of a power plant safety training lesson plan generation device based on intelligent agents and skill packs, provided as an embodiment of this application. Detailed Implementation

[0020] The technical solutions in the embodiments of this application will now be described with reference to the accompanying drawings.

[0021] like Figure 1 As shown, this embodiment provides a method for generating power plant safety training materials based on intelligent agents and skill packages. This method is mainly executed collaboratively by the core layer of the intelligent agent and the skill center layer, constructing a fully automated closed loop from requirement input to training material output. Specifically, the method includes the following steps: Step S110: Obtain the lesson plan generation requirements, perform task planning based on the domain constraint rules, and generate a task plan.

[0022] Specifically, the user interaction layer receives lesson plan generation requests from users in natural language, such as training target type, training topic area, training duration, emphasis requirements, and assessment requirements.

[0023] After the task planner in the core layer of the intelligent agent obtains the requirement, it calls the large language model to perform semantic parsing and extract structured requirement elements. Subsequently, the task planner, combined with pre-defined domain constraint rules, breaks down the overall task of lesson plan generation into an ordered sequence of subtasks, forming a task plan. This task plan specifies the skill package name to be invoked by each subtask, the input parameters, and the dependencies between subtasks.

[0024] For example, a task plan can include sequentially executed subtasks of "knowledge retrieval" and "lesson plan generation," or it can include multiple knowledge retrieval subtasks executed in parallel. Domain constraint rules are injected into the task planner in the form of structured configurations or prompt words, so that the large language model is deeply constrained by the power plant safety business specifications when decomposing tasks, ensuring the professional compliance of the generated content from the source.

[0025] It should be understood that domain constraint rules are not limited to the field of power plant safety, but can also be dynamically configured according to different application scenarios. For example, they can be replaced with safety rules for high-risk industries such as chemical and coal mining, as long as they can constrain the task decomposition process.

[0026] Step S120: Execute the corresponding skill pack according to the task plan to generate the initial lesson plan.

[0027] Specifically, the execution controller of the core layer of the intelligent agent obtains the current task plan to be executed from the task planner, and initiates a skill call request to the skill center layer according to the order and dependencies in the task plan.

[0028] The skills center layer encapsulates various atomic capabilities in the form of "skill packages," such as knowledge retrieval skill packages, case matching skill packages, content arrangement skill packages, lesson plan generation skill packages, and test question generation skill packages.

[0029] The execution controller collects the results returned by each skill pack and passes the results of previous tasks as input parameters for subsequent tasks according to the task plan. For example, the list of legal clauses returned by the "Knowledge Retrieval" skill pack is passed to the "Content Arrangement" skill pack as material input, and finally the "Lesson Plan Generation" skill pack generates an initial lesson plan containing a complete chapter structure and key content points.

[0030] During this process, the memory manager is responsible for maintaining the short-term memory of the current session, storing the results of executed subtasks and intermediate content fragments to ensure the consistency of the lesson plan generation process.

[0031] The skill center layer supports dynamic registration, discovery, and invocation of skills. When new capabilities need to be added, simply implement the new skill package according to the standard interface specification and register it in the system. The task planner can then automatically learn the functional description of the new skill package through the large language model and incorporate it into the task plan without modifying the core code of the agent, thus achieving flexible expansion of the system's capabilities.

[0032] Step S130: Perform compliance verification on the initial lesson plan.

[0033] Specifically, the compliance verification skill package at the skill center level serves as the final quality checkpoint for lesson plan output, automating compliance checks on the generated initial lesson plan content. The compliance verification skill package scans and analyzes the initial lesson plan using preset verification dimensions to determine whether it meets the actual business processes and regulatory requirements of power plant safety management.

[0034] For example, a compliance verification skill set can check whether the regulatory provisions cited in the initial lesson plan are the current and valid versions, whether the safety terminology used conforms to the standard terminology definitions in the power industry, and whether the lesson plan contains the necessary structural elements.

[0035] By introducing a compliance verification mechanism, we can effectively identify and block illusions and factual errors that may arise when large language models generate professional content, ensuring the authority and accuracy of the training content.

[0036] Step S140: In response to the failure of compliance verification, task replanning is triggered to update the task plan and re-execute until compliance verification passes, and the target teaching plan is output.

[0037] Specifically, when the compliance verification skill package detects non-compliance items in the initial lesson plan, the execution controller triggers an exception handling and replanning mechanism.

[0038] Upon receiving an anomaly signal, the task planner adjusts task parameters or replaces skill packs, generates an updated task plan, and reschedules its execution. For example, if a compliance check reveals that the initial lesson plan references outdated regulations, the task planner can update the query parameters of the "Knowledge Retrieval" subtask, requiring that only currently valid versions of regulations be retrieved, and then re-execute the subsequent orchestration and generation steps.

[0039] This process is repeated until compliance verification is passed, and finally, a target lesson plan that meets the requirements is output to the user. This embodiment constructs a dynamic error correction closed loop of "planning-execution-verification-replanning," enabling the intelligent agent to have self-correction capabilities, which significantly improves the accuracy, timeliness, and system reliability of lesson plan generation.

[0040] We will continue to provide a detailed explanation of the specific process of task planning and the method of injecting domain constraint rules.

[0041] Based on domain constraint rules, task planning is performed on the requirement to generate a task plan, including: semantic parsing of the requirement to extract structured requirement elements; and based on the structured requirement elements and the domain constraint rules, the requirement is decomposed into a sequence of sub-tasks with dependencies, which serve as the task plan.

[0042] Specifically, after receiving the lesson plan generation requirements in natural language form, the task planner first calls a large language model to perform semantic parsing, extracting structured requirement elements from the unstructured text. These structured requirement elements include, but are not limited to, the type of training target, the training topic area, the training duration, the focus requirements, and the assessment requirements.

[0043] Subsequently, instead of directly passing these elements to subsequent execution stages, the task planner jointly encodes the structured requirement elements with pre-defined domain constraint rules. Leveraging the reasoning capabilities of the large language model, it decomposes the overall task into a sequence of subtasks with dependencies. These dependencies include sequential and parallel dependencies; for example, the knowledge retrieval subtask must be executed before the lesson plan generation subtask, while multiple knowledge retrieval subtasks with different dimensions can be executed in parallel. This explicit task decomposition avoids the limitations of a general-purpose large language model when faced with complex tasks. Figure 1 The loose structure caused by the step-by-step generation of results makes the lesson plan generation process controllable and highlights the key points.

[0044] The constraints in this area include at least one of regulatory traceability requirements and specific measure priority requirements.

[0045] Among them, the requirement for legal source tracing is that the content of the lesson plan must be associated with the corresponding legal source; the requirement for priority of specific measures is that, in response to the work project involved in the requirement, priority should be given to searching for at least one of the organizational measures, technical measures and safety measures.

[0046] Specifically, the regulatory source tracing requirement mandates that any safety requirement or operational procedure appearing in the lesson plan must be traceable to at least one specific legal, regulatory, or procedural clause. During the task decomposition phase, this regulatory source tracing requirement is injected as a structured constraint into the task planner. This forces the task planner to establish a parameter mapping between the knowledge retrieval subtask and the lesson plan generation subtask when generating a sequence of subtasks. The knowledge retrieval subtask must return results containing metadata such as clause content, source, and effective date, which serves as a mandatory input parameter for the lesson plan generation subtask.

[0047] In this way, each piece of content can be automatically marked with its source when the lesson plan is generated, supporting tracing back to the original document in the knowledge base layer. This effectively eliminates false content generated by the illusion of the large language model and ensures the authority of the training content.

[0048] Prioritizing specific measures constrains training needs related to specific work projects. When the task planner identifies specific work projects such as hot work, work at height, and confined space work through semantic parsing, prioritizing specific measures is triggered. When breaking down the task, the task planner forcibly generates a sub-task specifically for retrieving organizational, technical, and safety measures.

[0049] Taking hot work operations in the field of power plant safety as an example, when breaking down requirements, the task planner will forcibly generate sub-tasks to retrieve "three measures and two plans," ensuring that the final generated lesson plan covers the complete content of organizational measures, technical measures, and safety measures. This mechanism deeply embeds the specific business processes in the field of power plant safety into the decision-making logic of the intelligent agent, enabling the generated lesson plan to be seamlessly connected with actual safety management operations, avoiding the shortcomings of general models that only generate general safety precautions and are divorced from actual operation guidance.

[0050] Domain constraint rules are not hard-coded into the task planner's program code, but exist as independent structured configuration files or are dynamically injected into the context of the large language model as system prompts. When different power generation companies have personalized business rules, such as a nuclear power plant requiring all nuclear-related operations to be aligned with nuclear safety regulations, the system only needs to update the corresponding configuration files or modify the prompts. The task planner can then automatically load and apply the new constraint rules to decompose the task, without requiring code refactoring and redeployment of the agent's core layer.

[0051] This dynamic loading mechanism decouples business rules from core control logic, supporting not only flexible rule expansion but also rapid migration to other high-risk industries such as chemical and coal mining, significantly improving reusability and engineering implementation efficiency.

[0052] We will continue to provide detailed explanations of the specific dimensions of compliance verification and the abnormal conditions that trigger task replanning.

[0053] The initial lesson plan should be subject to compliance verification, including at least one of the following dimensions: verification of the timeliness of regulations, verification of the standardization of terminology, and verification of the completeness of content.

[0054] Specifically, after receiving the initial lesson plan, the compliance verification skill kit will automatically scan and analyze it from multiple dimensions.

[0055] Among them, the timeliness of regulations is used to verify whether the laws, regulations, industry standards and enterprise procedures cited in the teaching plan are still in effect; the standardization of terminology is used to compare whether the professional terms in the teaching plan text are consistent with the terminology definitions of the power industry standards, so as to prevent ambiguity in safety guidance due to colloquial or non-standard expressions; and the completeness of content is used to check whether the teaching plan has the necessary structural elements for teaching activities, such as learning objectives, training targets, training duration, main content and assessment methods.

[0056] It should be understood that the above verification dimensions are merely illustrative. In other implementations, dimensions such as sensitive content filtering and logical consistency verification can be added according to the different safety management priorities of different power plants, as long as the initial lesson plan can be automatically checked for compliance. Through multi-dimensional cross-verification, a three-dimensional protection network for lesson plan quality is constructed, effectively intercepting illusions and factual errors that may be generated by large language models.

[0057] The verification of the timeliness of regulations includes: verifying whether the regulatory provisions cited in the initial lesson plan are the current valid versions; in response to the existence of new and old versions of the same regulation, only the content of the new version is retained, and the content of the old version is marked as obsolete.

[0058] Specifically, regulations and standards in the field of power plant safety are constantly revised and updated over time. Using outdated regulations for safety training can pose serious safety hazards. When performing regulatory timeliness checks, the compliance verification skill package extracts the source and version information of the regulations marked in the initial training materials and initiates a query request to the regulatory standards database at the knowledge base layer. When multiple versions of the same regulation are found, the version number or publication date is compared to determine whether the current training material references the latest version.

[0059] If a lesson plan references content from an older version, it will not only fail the verification process but will also be automatically replaced: only the new version's legal provisions will be retained, and a "repealed" label will be added next to or in the corresponding position of the old version's content to remind trainers of the version differences. This approach ensures both the absolute timeliness of the lesson plan content and the preservation of comparative information on version changes, helping trainers understand the evolution of regulations.

[0060] Abnormal conditions that trigger task replanning include at least one of the following: the execution result of the skill pack is empty; compliance verification determines that the initial lesson plan references repealed regulatory clauses.

[0061] Specifically, anomalies are inevitable throughout the entire lifecycle of lesson plan generation. When a skill package returns an empty result—for example, if the knowledge retrieval skill package fails to find relevant clauses in the regulatory standards library, or the case matching skill package fails to find a matching typical accident case—the execution controller will capture this empty return value and classify it as an anomaly. Similarly, when the compliance verification skill package detects that the initial lesson plan references obsolete regulatory clauses, an anomaly signal will also be generated. Once any of the above anomalies is met, the execution controller will immediately interrupt the current task execution flow and backtrack the anomaly context information to the task planner. Upon receiving the anomaly signal, the task planner will adjust the task plan based on the cause of the anomaly, such as expanding the scope of search keywords, changing the data source, or adding specific filtering parameters, thereby generating an updated task plan and rescheduling its execution.

[0062] This embodiment enables the intelligent agent to have keen fault perception and error correction capabilities by clearly defining specific abnormal triggering conditions, thus ensuring the robustness of the lesson plan generation task in a complex knowledge base environment.

[0063] To further balance system reliability and execution efficiency, this embodiment also proposes a multi-level cascaded verification and backtracking replanning mechanism.

[0064] Specifically, the compliance verification skill package is designed with a cascading structure of multiple verification levels. For example, regulatory timeliness verification is set as the first level, terminology standardization verification as the second level, and content completeness verification as the third level. When a single point of verification at a certain level fails, the system does not immediately trigger a full replanning of the global task schedule, but only triggers a local retry for that point of failure. For example, if the terminology standardization verification fails, the execution controller only calls the lesson plan generation skill package again, requiring it to make local corrections to specific paragraphs based on the terminology standardization dictionary, without having to re-execute pre-processing tasks such as knowledge retrieval.

[0065] Only when local retries reach a preset number and still fail the validation, or when a global anomaly occurs (such as an empty core knowledge retrieval result), will the system trigger a full replanning, backtracking to the task planner to re-decompose the task sequence. This hierarchical anomaly handling strategy ensures the quality of the final lesson plan while minimizing unnecessary computational resource consumption, significantly improving the system's concurrent processing capabilities and response speed.

[0066] The following example, using the generation scenario of a training material for outsourced maintenance personnel working at heights in a thermal power plant, provides a detailed explanation. It should be understood that this scenario is illustrative only, not restrictive; the proposed solution is also applicable to other safety training scenarios such as hot work and confined space operations.

[0067] like Figure 2 As shown, the system architecture consists of a knowledge base layer, a skill center layer, an intelligent agent core layer, and a user interaction layer from bottom to top, realizing a closed loop across the entire chain from underlying knowledge support to top-level business applications.

[0068] The user interaction layer receives training plan generation requests from users in natural language, such as the target audience, training topic, duration requirements, key points, and assessment methods, and returns the final generated plan and a description of the generation process to the user.

[0069] The core layer of the intelligent agent uses a large language model as its inference engine and includes three sub-modules: task planner, memory manager, and execution controller. It is responsible for understanding user needs, formulating task execution plans, managing dialogue and task context, and scheduling relevant skills from the skill center to complete various sub-tasks.

[0070] The Skill Center layer encapsulates various atomic capabilities in the form of "skill packages." Each skill package follows a unified input / output interface specification, including skill packages for knowledge retrieval, case matching, content arrangement, lesson plan generation, exam question generation, and compliance verification. The Skill Center supports dynamic registration, discovery, and retrieval of skills, exhibiting excellent scalability.

[0071] The knowledge base layer, also known as the power plant safety knowledge base, stores laws, regulations, policies, standards, internal procedures, "three measures and two plans" documents, a fault case library, a historical training material library, and an examination question bank related to power plant safety production. The knowledge base provides standard interfaces such as semantic search, keyword search, and knowledge graph query to provide authoritative knowledge support for the operation of the skill package.

[0072] The core of the intelligent agent is the central control and decision-making unit of this invention, and its internal structure and workflow are as follows: The task planner receives the user's original requirement text and performs the following operations: Requirements Analysis: The large language model is invoked to perform semantic analysis on user input, extract key requirement elements, and form a structured requirement specification.

[0073] Demand elements include, but are not limited to: Training target audience: such as new employees, outsourced personnel, special operations personnel, managers, etc.; Training topics: such as working at heights, hot work, confined spaces, electrical safety, emergency first aid, etc.; Training duration: specific duration in minutes; Emphasis: such as "focusing on emergency response," "emphasizing legal basis," "using real-world cases," etc.; Assessment requirements: whether test questions are required, the number and type of test questions; Format requirements: PPT outline, Word document, web page text, etc.

[0074] Task decomposition and plan generation. Based on the parsed requirements specification, the task planner calls the large language model to decompose the overall task of lesson plan generation into an ordered sequence of subtasks (i.e., the task plan). The task plan specifies the skill pack name and input parameters to be called by each subtask, as well as the dependencies between subtasks (serial or parallel).

[0075] The memory manager is responsible for maintaining the agent's contextual memory, which is divided into two categories: Short-term memory: stores user requirements in the current session, results of executed subtasks, and intermediate content fragments, for subsequent subtasks to reference, ensuring consistency in the lesson plan generation process. Long-term memory: stores historically generated successful lesson plans and their corresponding requirement specifications and task plans in the form of a vector database, forming an experience base. When new requirements are similar to historical experience, the task planner can refer to historical task plans, accelerating the planning process and improving plan quality.

[0076] The Execution Controller acts as the scheduling hub between the agent and the Skill Center. Its workflow is as follows: It obtains the current task plan from the Task Planner. Following the order and dependencies in the task plan, it sequentially sends skill call requests to the Skill Center. For subtasks that can be executed in parallel (such as simultaneously retrieving multiple knowledge bases), the Execution Controller concurrently calls multiple skill packages to improve efficiency. It collects the return results of each skill package and, according to the task plan, passes the results of preceding tasks as input parameters for subsequent tasks. For example, the list of legal clauses returned by the "Knowledge Retrieval" skill package is passed to the "Content Arrangement" skill package as material input. If a skill package call fails or the returned result does not meet quality requirements (such as an empty search result), the Execution Controller can trigger task replanning, requiring the Task Planner to adjust parameters or replace the skill package before re-execution.

[0077] The Skill Center is a container for registering, managing, and running skill packages. Each skill package is an independent functional module that exposes a unified API. This invention defines the following core skill packages: The knowledge retrieval skills package encapsulates various retrieval capabilities for the power plant safety knowledge base, including: Regulatory clause retrieval: Based on the query topic and keywords, it retrieves relevant legal provisions and standard specifications from the regulatory and standard knowledge base, returning a result list containing metadata such as clause content, source, and effective date. Internal procedure retrieval: It retrieves relevant plant-level safety management systems, operating procedures, and work instructions from the internal procedure and system database. "Three Measures and Two Plans" retrieval: It specifically performs structured retrieval of documents related to organizational measures, technical measures, safety measures, emergency plans, and emergency response plans, allowing extraction of measure entries. Knowledge graph query: For power plant safety knowledge bases with constructed knowledge graphs, it supports retrieving related knowledge (such as common risks of a certain equipment, related measures for a certain operation, etc.) through entity links and relationship queries.

[0078] This skill set employs a two-stage retrieval strategy of "coarse ranking - fine ranking". First, candidate document fragments are retrieved through vector similarity retrieval. Then, LLM performs relevance ranking and content refinement on the candidate fragments, and finally returns highly relevant and concisely expressed knowledge fragments.

[0079] The case matching skill package is responsible for matching real-world accident cases and typical violation cases relevant to the training topic from a fault case database. Its core capabilities include: Semantic matching: Retrieving relevant cases from the case database based on semantic vectors of the training topic and focus. Case selection and ranking: Ranking cases according to their educational value (e.g., severity of accident consequences, typicality of causes, and relevance to training content), selecting the most pedagogically significant cases. Case summary generation: Automatically generating summaries for selected cases, including the accident sequence, direct causes, indirect causes, lessons learned, and preventative measures, facilitating integration into teaching materials.

[0080] The content arrangement skill package is responsible for logically arranging various retrieved knowledge materials to form the chapter structure and content allocation of lesson plans. Its processing flow is as follows: Material Clustering and Theme Division: Semantic clustering is performed on the content returned by knowledge retrieval and case matching to divide it into several teaching theme units (such as "regulatory requirements," "risk identification," "safety measures," "emergency response," etc.). Time Allocation: Based on the total training time specified by the user, the system intelligently calculates the time allocation scheme for each theme unit to ensure that key content receives sufficient time. Logical Sequencing: The theme units are sorted according to the laws of teaching cognition (such as from simple to complex, theory before cases, risk before measures) to generate a lesson plan outline. Interactive Activity Design: Based on the time and nature of the theme, suggestions for interactive activities (such as questions, group discussions, practical demonstrations, etc.) are inserted at appropriate locations.

[0081] The lesson plan generation skill package, based on the content, arranges the output lesson plan outline and materials, and uses a large language model to generate the final training lesson plan text. The generation process follows these principles: Template Constraints: The system presets multiple lesson plan format templates (such as PPT presentation templates, teacher manual templates, and student handout templates). The appropriate template is selected based on the user's specified format requirements, and the LLM (Learning Model) fills in the content within the template framework to ensure format standardization. Style Adaptation: The language style is adjusted according to the type of training audience. For example, when targeting outsourced personnel, easy-to-understand conversational language is used; when targeting managers, the focus is on legal basis and management responsibility analysis. Source Citation: All legal clauses, standards, and accident cases cited in the lesson plan are clearly marked with their sources, supporting tracing back to the original documents at the knowledge base layer. Multimodal Support: For sections requiring illustrations (such as equipment structure diagrams and operation flowcharts), the lesson plan generation skill package can output image placeholders and image requirement descriptions for subsequent manual or automatic image addition.

[0082] The test question generation skill package automatically generates corresponding assessment questions based on lesson plan content and assessment requirements. It supports multiple question types: Objective questions: multiple choice, true / false, and multiple selection questions, generated comprehensively from the knowledge base's historical question bank and lesson plan knowledge points, ensuring a high degree of relevance between the questions and the lesson plan content. Scenario analysis questions: open-ended analysis questions generated based on accident cases or hypothetical work scenarios in the lesson plan, assessing students' comprehensive application abilities. Operation sequencing questions: generating operation step sequencing questions for safety skills knowledge points.

[0083] The generated exam questions simultaneously output standard answers and explanations. The explanations indicate the sources of the knowledge, making it easier for students to review.

[0084] The compliance verification skill package serves as the final quality checkpoint for lesson plan output, automating compliance checks on the generated lesson plan content. Checks include: Regulatory timeliness check: Verifying that the regulatory clauses cited in the lesson plan are current and valid versions; issuing warnings for cited repealed clauses. Terminology standardization check: Checking that the safety terminology used in the lesson plan conforms to the standard definitions of the power industry, preventing ambiguity caused by colloquial expressions. Sensitive content filtering: Scanning the lesson plan text for sensitive words, filtering expressions that do not conform to safety values ​​or may cause misunderstandings. Completeness check: Checking whether the lesson plan contains necessary structural elements (such as learning objectives, target audience, training duration, main content, assessment methods, etc.).

[0085] The skill package registration and expansion mechanism employs a plug-in architecture in the Skill Center, defining a standard skill package interface specification. Each skill package must implement the following standard methods: `get_skill_info()`: Returns the skill package's name, version, function description, input parameter schema, and output format schema. `execute(params, context)`: Executes the core logic of the skill package, receiving input parameters and a context object, and returning the execution result.

[0086] When new capabilities need to be added to the system, developers simply need to implement the new skill package according to the interface specification and register it with the system through the skill center's registration interface. The task planner can then automatically learn the functional description and applicable scenarios of the new skill package by calling the large language model, and incorporate it into the task plan in appropriate tasks. This design enables flexible expansion of the system's capabilities without modifying the agent's core code.

[0087] Based on the intelligent agent constraints of power plant safety business logic, to ensure that the training materials generated by the intelligent agent conform to the actual business processes of power plant safety management, this invention embeds the following domain constraint rules into the core of the intelligent agent: "Three Measures and Two Plans" Priority Rule: When the training topic involves specific operational projects, the task planner prioritizes calling the "Three Measures and Two Plans Retrieval" sub-skill to ensure that the training materials cover complete content of organizational measures, technical measures, and safety measures. Regulatory Source Tracing Rule: Any safety requirement in the training materials must be traceable to at least one specific regulation or procedure clause; otherwise, the compliance verification skill package will report an error. Training Closed-Loop Rule: If user requirements include assessment requirements, the task plan must include a question generation sub-task, and the knowledge point coverage of the questions must reach more than 80% of the knowledge points in the training materials. New and Old Version Handling Rule: When new and old versions of the same regulation exist in the knowledge base, the training materials only reference the new version; the old version is only used after being marked "obsolete" in comparative analysis scenarios.

[0088] These constraints are injected into the task planner and execution controller in the form of structured configurations or Prompt instructions, ensuring that the behavior of the agents is deeply aligned with the professional requirements of power plant safety training.

[0089] In this scenario, a safety training specialist inputs a natural language request through the user interaction layer: "Generate a 45-minute safety training lesson plan for outsourced maintenance personnel working at heights, focusing on the proper use of safety belts and emergency response measures, and also create a 20-question test." After receiving the lesson plan generation request, the system performs task planning based on domain constraint rules, generating a task plan.

[0090] Specifically, after receiving the natural language request, the task planner in the core layer of the intelligent agent performs semantic parsing to extract structured requirement elements: the training target is outsourced maintenance personnel, the training topic is safety at heights, the training duration is 45 minutes, the focus is on safety belt fastening procedures and emergency response measures, and the assessment requires 20 questions. Subsequently, the task planner decomposes the task based on pre-defined domain constraint rules. Since this requirement involves the specific task of working at heights, specific measures are prioritized and triggered. The task planner forcibly inserts subtasks specifically for retrieving organizational, technical, and safety measures into the generated subtask sequence, such as retrieving internal power plant documents on "three measures and two plans." Simultaneously, based on regulatory citation requirements, the task planner establishes a mandatory parameter mapping between the knowledge retrieval subtask and the lesson plan generation subtask, requiring the retrieval results to include meta-information such as clause content, source, and effective date, ensuring that the subsequently generated lesson plan content is linked to the corresponding regulatory source.

[0091] According to the task plan, the execution controller schedules the execution of the corresponding skill packs to generate the initial lesson plan.

[0092] Specifically, the execution controller sequentially schedules the knowledge retrieval skill package, case matching skill package, content arrangement skill package, and lesson plan generation skill package. The case matching skill package matches two typical fall-from-height accident cases from the fault case database. The lesson plan generation skill package generates a complete lesson plan text, including a title page, learning objective page, content pages for each section, and a summary page, based on the arranged outline. It also details the steps in the safety belt fastening procedure section and provides a flowchart description in the emergency response section. During this process, the memory manager is responsible for storing the results of executed subtasks and intermediate content fragments, ensuring the consistency of the lesson plan generation process.

[0093] Perform compliance verification on the initial lesson plan.

[0094] Specifically, the compliance verification skill package automates the scanning and analysis of generated initial lesson plans, with verification dimensions including regulatory timeliness and terminology standardization. When performing regulatory timeliness verification, the skill package checks whether the regulatory clauses cited in the initial lesson plan are currently valid versions. If both new and old versions of the same regulation are found, the system retains only the new version and marks the old version as obsolete. When performing terminology standardization verification, the system compares the professional terminology in the lesson plan text to ensure consistency with the terminology definitions in the power industry standards; for example, correcting the colloquial term "hanging a safety rope" to the standardized term "safety belt fastening."

[0095] In response to a failure to pass the compliance check, a task replanning is triggered to update the task plan and re-execute it until the compliance check passes, at which point the target lesson plan is output.

[0096] Specifically, if the compliance verification skill package detects that the initial lesson plan references obsolete regulations during the above verification process, the verification is deemed to have failed. The execution controller captures this anomaly signal and transmits it back to the task planner. The task planner adjusts the task plan based on the cause of the anomaly, such as updating the query parameters of the knowledge retrieval subtask, adding filtering conditions to exclude obsolete versions, generating an updated task plan, and rescheduling execution. Once the lesson plan is regenerated and passes verification, the system returns the complete training lesson plan text and accompanying exam questions to the safety training specialist, along with a description of the generation process, listing the referenced regulations, case sources, and the distribution of knowledge points in the exam questions. This embodiment, by applying the above mechanism in the specific scenario of power plant safety training, effectively overcomes the illusion problem and factual errors that are prone to occur when general-purpose large language models generate content in professional fields, ensuring the authority, timeliness, and compliance of the training content.

[0097] This embodiment describes the above solution from the perspective of the hardware architecture of the device entity. For example... Figure 3As shown, this embodiment provides a power plant safety training lesson plan generation device based on intelligent agents and skill packages. The device mainly includes a planning module 301, an execution module 302, and a verification and replanning module 303.

[0098] It should be understood that the modules in this embodiment are not virtual logical functions, but physical hardware modules with data processing and storage functions. For example, each module can be integrated into at least one processor, or it can be constructed by an independent processor in conjunction with memory and communication bus.

[0099] The planning module 301 is configured to obtain the lesson plan generation requirements, perform task planning based on the domain constraint rules, and generate a task plan.

[0100] Specifically, the planning module 301 is the decision-making center of the entire device, and its hardware can be embodied as a central processing unit (CPU), microcontroller (MCU), or application-specific integrated circuit (ASIC). The planning module 201 receives natural language input from the user through an external communication interface (such as an Ethernet interface or wireless network module) and invokes an internal or external large language model inference engine for semantic parsing and task decomposition. During the decomposition process, the planning module 201 reads a pre-set domain constraint rule configuration file from its local storage unit, embeds the rule constraints into the generated sub-task sequence, and finally outputs structured task plan data.

[0101] Execution module 302 is configured to schedule the execution of the corresponding skill pack according to the task plan and generate the initial lesson plan.

[0102] Specifically, the hardware carrier of the execution module 302 can also be an independent processor or processing chip, which interacts with the planning module 301 via an internal bus. The execution module 302 parses the subtask sequence and dependencies in the task plan and sends scheduling instructions to the skill center layer through an API call interface. The skill center layer is deployed in an independent application server or cloud container. The execution module 302 collects the execution results returned by each skill package (such as knowledge retrieval, lesson plan generation, etc.), temporarily stores intermediate data in a cache, and outputs the initial lesson plan text data after arrangement and integration.

[0103] The verification and replanning module 303 is configured to perform compliance verification on the initial lesson plan. In response to a failure of the compliance verification, it triggers task replanning to update the task plan and re-execute it until the compliance verification passes and the target lesson plan is output.

[0104] Specifically, the verification replanning module 303 can be composed of an independent verification processor and exception handling logic circuitry. This verification processor has a built-in rule comparison engine that receives the initial lesson plan generated by the execution module 202 and scans it from multiple dimensions. When a non-compliant item is detected (such as citing repealed regulations), the verification replanning module 303 generates an exception interrupt signal and sends this signal back to the planning module via the bus. This triggers the planning module to readjust its parameters and generate an updated task plan, thereby driving the execution module 302 to re-execute. This hardware-level closed-loop control mechanism ensures the absolute compliance of the output lesson plan.

[0105] To further refine the internal structure and coordination mechanism of each module, the planning module 301 includes a task planner and a memory manager. The task planner is configured to perform task planning and task replanning, and the memory manager is configured to store task plans and initial lesson plans. The verification and replanning module 303 includes an execution controller, which is configured to schedule skill packages and collect execution results.

[0106] Specifically, the task planner, as the core processing unit, is responsible for performing requirement parsing, task decomposition, and replanning logic in case of exceptions. The memory manager corresponds to physical storage media, such as random access memory (RAM) or solid-state drive (SSD), and is divided into short-term and long-term storage areas. The short-term storage area caches intermediate data of the task plan and initial lesson plans generated by the execution module for the current session, ensuring context consistency. The long-term storage area persistently stores historical successful lesson plans and their corresponding requirement specifications in the form of a vector database. When the task planner processes new requirements, it can prioritize retrieving similar experiences from the long-term storage area to accelerate planning. The execution controller in the verification and replanning module 303 acts as the scheduling hub, responsible for initiating call requests to the skill center layer and collecting return results. For example, the execution controller connects to an external skill package server via a high-speed serial computer expansion bus (PCIe), concurrently distributing multiple retrieval subtasks and monitoring the execution status of each skill package. When the execution controller detects exceptions such as a skill package returning a null value, it immediately sends a replanning request to the task planner. This embodiment clarifies the entity connection relationship and data interaction mechanism between the task planner, memory manager, and execution controller, mapping the abstract closed-loop control logic to a specific hardware collaboration architecture. This avoids functional limitations being left undefined and significantly improves the reliability and execution efficiency of the system when handling complex lesson plan generation tasks.

[0107] This embodiment provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the steps of the above-described method for generating power plant safety training materials based on intelligent agents and skill packages.

[0108] Specifically, the computer-readable storage medium may include, but is not limited to: read-only memory (ROM), programmable read-only memory (PROM), electrically erasable programmable read-only memory (EEPROM), random access memory (RAM), dynamic random access memory (DRAM), static random access memory (SRAM), solid-state drive (SSD), magnetic surface storage (such as hard disk), optical disc (such as CD-ROM, DVD), or cloud-distributed storage media. It should be understood that the storage media listed above are merely exemplary and not limiting; any physical or virtual medium capable of carrying computer program code and being readable by a processor can be used in this embodiment.

[0109] When the computer program is executed by the processor, the processor executes instructions according to the process described in any of the foregoing embodiments. The processor first obtains the lesson plan generation requirements, performs task planning based on domain constraint rules, and generates a task plan; then, it schedules the corresponding skill packs to be executed according to the task plan to generate an initial lesson plan; next, it performs compliance verification on the initial lesson plan; if the verification fails, it triggers task replanning to update the task plan and re-executes it, repeating the process until the compliance verification passes, and finally outputs the target lesson plan.

[0110] By converting the above methods and steps into computer program instructions and embedding them in a storage medium, the medium can be distributed, deployed, and upgraded as an independent software product. For example, in the safety training management systems of various power generation enterprises such as thermal power plants and hydropower plants, simply connecting the storage medium to the system host can quickly endow it with the ability to automatically generate intelligent teaching materials and perform compliance verification, significantly reducing the deployment threshold and maintenance costs of the software, while ensuring the consistency and reliability of core business logic.

[0111] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A method for generating power plant safety training materials based on intelligent agents and skill packages, characterized in that, include: Obtain the lesson plan generation requirements, perform task planning based on the requirements according to the domain constraint rules, and generate a task plan; The corresponding skill packs are executed according to the task plan to generate initial lesson plans; The initial lesson plan was verified for compliance. In response to the failure of the compliance check, a task replanning is triggered to update the task plan and re-execute it until the compliance check passes, at which point the target teaching plan is output.

2. The method according to claim 1, characterized in that, The domain constraint rules include at least one of regulatory traceability requirements and specific measure priority requirements.

3. The method according to claim 2, characterized in that, The requirement for legal source tracing is that the content of the lesson plan must be linked to the corresponding legal source. The specific measures require prioritizing the retrieval of at least one of organizational measures, technical measures, and safety measures in response to the operational items involved in the requirement.

4. The method according to claim 1, characterized in that, The compliance verification of the initial lesson plan includes at least one of the following dimensions: Verification of the timeliness of regulations, verification of the standardization of terminology, and verification of the completeness of content.

5. The method according to claim 4, characterized in that, The timeliness verification of the regulations includes: Verify that the legal provisions cited in the initial lesson plan are the current and valid versions; In response to the existence of both new and old versions of the same regulation, only the content of the new version is retained, and the content of the old version is marked as obsolete.

6. The method according to claim 1, characterized in that, The process of planning tasks based on domain constraint rules to generate a task plan includes: The requirements are semantically parsed to extract structured requirement elements; Based on the structured requirement elements and the domain constraint rules, the requirement is decomposed into a sequence of sub-tasks with dependencies, which serves as the task plan.

7. The method according to claim 1, characterized in that, The abnormal conditions that trigger the task replanning include at least one of the following: The execution result of the skill pack is empty; The compliance check determined that the initial lesson plan referenced repealed regulatory provisions.

8. A power plant safety training lesson plan generation device based on intelligent agents and skill packages, characterized in that, include: The planning module is configured to acquire lesson plan generation requirements, perform task planning based on the requirements according to domain constraint rules, and generate a task plan. The execution module is configured to schedule the execution of the corresponding skill pack according to the task plan and generate the initial lesson plan; The verification and replanning module is configured to perform compliance verification on the initial lesson plan. In response to the failure of the compliance verification, it triggers task replanning to update the task plan and re-execute it until the compliance verification passes, and then outputs the target lesson plan.

9. The apparatus according to claim 8, characterized in that, The planning module includes a task planner and a memory manager. The task planner is configured to perform the task planning and the task replanning, and the memory manager is configured to store the task plan and the initial lesson plan. The verification replanning module includes an execution controller configured to schedule the skill pack and collect execution results.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the method of any one of claims 1 to 7.

Images