Program control instruction generation method based on large model federal prompt fine tuning

Abstract

The invention discloses a program control instruction generation method based on large model federation prompt fine tuning, which realizes the collaborative utilization of multi-party data on the premise of protecting the data privacy of each party by constructing a multi-level conditional diffusion model federation learning architecture. The problem of rapid adaptation of new equipment is solved through a heterogeneous document-oriented hierarchical retrieval enhancement generation method, and the problems of information fragmentation and text discontinuity in the traditional RAG technology are solved by constructing an operation process knowledge graph and a multi-granularity semantic representation learning framework and adopting a continuous perception retrieval mechanism. And finally, solving a fundamental contradiction between large model probability generation and test instruction preciseness through a constraint satisfaction deterministic generation mechanism, and converting a probability generation process into a strict logical reasoning process by adopting a beam search algorithm guided by a complete deterministic constraint. By constructing a three-dimensional constraint system of grammar constraint, semantic constraint and security constraint and a multi-stage verification mechanism, each generated instruction is ensured to have uniqueness, correctness and security.

Description

Technical Field

[0001] This invention belongs to the technical field of electronic test and measurement, specifically relating to a method for generating programmable instructions based on large model federated prompts for fine-tuning. Background Technology

[0002] In the field of electronic test and measurement, the writing of instrument control instructions has long relied on manual labor. Test engineers need to manually write each test instruction and parameter configuration based on specific test requirements and equipment operation manuals. This traditional method is not only inefficient and error-prone, but also demands extremely high professional skills from testers, severely restricting the large-scale application of automated testing. In recent years, the powerful capabilities of large language models in code generation and natural language understanding have provided a new technical path for the automatic generation of test instructions, potentially completely changing the traditional manual writing mode. However, general pre-trained large models lack professional knowledge in the field of electronic test and measurement, and direct application often fails to generate test control instructions that conform to specifications. Therefore, fine-tuning is required to adapt them to specific test scenarios and equipment characteristics.

[0003] The effectiveness of fine-tuning large models largely depends on the quality and quantity of training data. More diverse real-world test data can significantly improve the model's generalization ability across different test scenarios. Ideally, if data from multiple institutions can be pooled for joint training, model performance will be greatly enhanced. However, the parameter configurations and testing procedures involved in the testing process often contain core technical secrets of enterprises. For data security and privacy protection reasons, this sensitive data cannot be directly shared or centrally stored. Federated learning technology provides a solution to this dilemma, allowing multiple parties to collaboratively train the model without sharing the original data. However, there are significant differences in equipment models, test tasks, and instruction sets among different testing institutions, and the non-independent and identically distributed nature of the data limits the performance of the global model. More importantly, the generation of test instructions faces a completely different level of rigor compared to traditional code generation. In traditional code generation tasks for large language models, the same function can have multiple different implementations and expressions, and this flexibility is precisely its advantage. However, in the field of automated testing, each test instruction must be uniquely determined; there is no space for "synonymous expressions." Any deviation in any character can lead to the failure of programmable instruction execution, and in severe cases, it can even cause equipment damage or safety accidents. Furthermore, real-world testing scenarios involve numerous instruments and equipment from different manufacturers and models. The operating specifications and instruction sets for each device may differ, making it impossible to collect the operation manuals for all devices during the model fine-tuning phase. Moreover, re-fine-tuning the model for each new device is extremely costly. While retrieval-enhanced generation techniques can dynamically incorporate device-related knowledge, the operation manuals for testing instruments typically contain complex dependencies and strict operational sequences. Conventional text slicing and retrieval methods can disrupt this structured information, resulting in generated instructions lacking completeness and accuracy. Summary of the Invention

[0004] To address the aforementioned problems in existing technologies, this invention proposes a programmable instruction generation method based on large-model federated prompts for fine-tuning. This method is rationally designed, overcomes the shortcomings of existing technologies, and achieves good results.

[0005] To achieve the above objectives, the present invention adopts the following technical solution: The method for generating programmable instructions based on large-model federated hints for fine-tuning includes the following steps: S1: In the federated prompt fine-tuning phase, a federated learning network is established, comprising a central server and multiple clients. The central server initializes a multi-level conditional diffusion model and distributes it to each client. Each client, based on its local dataset, keeps the pre-trained large model parameters frozen and uses local device information, task description, and instruction requirements as input conditions to train the multi-level conditional diffusion model to generate prompt vectors. After training, each client uploads the trained model parameters to the central server. The central server uses a hierarchical weighted aggregation mechanism to weight and aggregate the diffusion model parameters at each level based on the similarity of data distribution and the contribution of each client to model performance at each level, obtaining an updated global multi-level conditional diffusion model, which is then distributed to each client for multiple rounds of iterative training until the model converges. S2: In the inference generation stage, user test requests are received; based on the user test requests, relevant contextual information is retrieved from the pre-built device document knowledge graph through intent-driven structured query to generate hard cue vectors; the user test requests and the retrieved contextual information are used as conditions and input into the multi-level conditional diffusion model obtained through federated training, and a deterministic dynamic soft cue vector is generated by fixing the initial noise seed and using a deterministic sampling strategy for reverse diffusion; the encoded embedding of the user test requests, the hard cue vectors, and the dynamic soft cue vectors are jointly input into the pre-trained large model, and a candidate programmable instruction sequence is generated using a fully deterministic bundle search algorithm; the candidate programmable instruction sequence is serially verified and backtracked for correction, and standardized programmable instructions are output.

[0006] Furthermore, the multi-level conditional diffusion model includes a three-layer structure of conditional cascade from top to bottom, comprising a device layer, a task layer, and an instruction layer; The device-layer diffusion model is used to generate device-aware prompt features based on the input heterogeneous device attribute information. It adopts a U-Net architecture and integrates a multimodal conditional coding sub-network. This sub-network includes a discrete attribute coding branch for processing device model, manufacturer, and interface type; a continuous attribute coding branch for processing frequency range and precision values; and a structured attribute coding branch for processing hierarchical configuration information. The outputs of the three branches are integrated into a device condition vector through a gating fusion mechanism. The formula for its calculation is: ; in, It is the sigmoid activation function. For the gated weight matrix, Represents element-wise product. The output vector of the discrete attribute encoding branch. The output vector for encoding branches of continuous attributes. The output vector of the structured attribute encoding branch. This is a direct concatenation of the three branch vectors; The residual block of the U-Net architecture in the device layer integrates an adaptive feature modulation layer, which dynamically adjusts the statistical properties of the feature representation based on the device condition vector through conditional batch normalization. ; in and The scaling and offset parameters are predicted by the device conditions. For conditionally batch normalized output, For input features, The mean, Standard deviation; The device-layer diffusion model also introduces an attention mechanism for device constraint awareness, the calculation formula of which is: ; in, The mask matrix is ​​constructed based on device constraints. For querying the matrix, The key matrix, Let be the dimension of the key vector. For value matrices, This is the output of the attention mechanism.

[0007] Furthermore, the task-layer diffusion model adopts a Transformer-Diffusion hybrid architecture and includes a task-dependent graph attention network. Its graph attention calculation process considers the partial order constraint of task execution, and the calculation formula is as follows: ; in, Task depends on indicator functions, For learnable query transformation weight matrix, The learnable key transformation weight matrix, Transform the weight matrix to learnable values. and The first and Feature representation vectors of each task node The output of the graph attention mechanism represents the first... The task node for the first Attention-weighted features of each task node; The task layer employs a dual-space joint diffusion mechanism to simultaneously perform the diffusion process in the feature space and graph space, where the graph space diffusion is achieved through a graph Laplacian diffusion kernel: ; in, The Laplace matrix of the task dependency graph. For time step Graph structure; The instruction layer diffusion model embeds the abstract syntax tree structure of program-controlled instructions into the diffusion process, employs a tree-structure-aware diffusion network, and its encoder integrates Tree-LSTM and Transformer, exchanging information through a structure-sequence dual attention mechanism. ; in, The output representation of the structure-sequence dual attention mechanism is a comprehensive feature vector that integrates sequence information and tree structure information. For the serialization encoding of program control instructions, Structured encoding for abstract syntax trees, This represents a vector concatenation operation. For sequence-to-tree attention function, For the attention function from tree to sequence; The diffusion process of the instruction layer adopts a diffusion variant of the masked language model, and achieves differentiable diffusion of discrete tokens through Gumbel-Softmax reparameterization, with the following distribution: ; in, For temperature parameters, This is the Gumbel noise distribution function, used to generate random noise with a Gumbel distribution, making the discrete sampling process differentiable. Let be the conditional probability distribution for the backdiffusion process, representing the probability of predicting the state at time step t−1 from the state at time step t. Let be the predicted probability distribution at time step t−1.

[0008] Furthermore, in the aforementioned hierarchical weighted aggregation mechanism, for the first... Layer diffusion model, the first Aggregate weight of each client Calculated dynamically using the following formula: ; in, Indicates the first The client in the first The model parameters corresponding to the layer, Indicates the global model at the 1st The model parameters corresponding to the layer, The similarity of the training data distribution is approximately reflected by the cosine similarity between the client-side model parameters and the global model parameters. The performance contribution is represented by the loss value of the local validation set reported by the client and the number of training samples, and the inverse of the loss weighted by the number of samples is used as the performance metric. This refers to the temperature parameter.

[0009] Furthermore, the construction of the device operation knowledge graph and the generation of the hard cue vectors include the following steps: S21: Using a layout analysis model based on convolutional neural networks, the device operation manuals in PDF and Word formats are parsed, and chapter titles, operation step sequences, parameter tables, and dependencies are automatically identified. S22: Based on the parsing results, construct a knowledge graph with operation step nodes, parameter configuration nodes, device status nodes, condition judgment nodes, exception handling nodes, and result verification nodes as core types, and time-series execution relationships, conditional branch relationships, parameter dependency relationships, exception handling relationships, state transition relationships, and reference relationships as edge relationship types; introduce physical continuity edges to connect text blocks that are physically separated in the original document due to line breaks, column breaks, and page breaks but logically belong to the same semantic unit; S23: After retrieving multiple scattered text fragments, a physical adjacency graph between fragments is constructed by analyzing the physical location information of the fragments in the original document, and heuristic rules are used to connect the text. The rules include: hierarchical judgment rules based on the same indentation level and font style, sequence matching rules based on consecutive numbering patterns, and sentence integrity judgment rules based on the punctuation at the end of the previous sentence and the character at the beginning of the next sentence. The connection process is supplemented by semantic embedding similarity verification and contextual logic consistency checks. S24: Hierarchical Semantic Representation Learning: The text content in the knowledge graph is encoded using a four-level architecture: lexical, sentence, paragraph, and chapter levels. The encoders at each level fuse information through a cross-level attention mechanism, ultimately resulting in a fused representation. The calculation is as follows: ; in, For the first Layer representation, For query vector, These are learnable weights; S25: When a user inputs a testing request, key entities are first extracted using named entity recognition and mapped to corresponding nodes in the knowledge graph; simultaneously, the user's query intent is identified using an intent classification model, with the intent recognition probability calculated using the softmax function. ; in, For the first The learnable weight vector corresponding to the class intent, For the first The learnable weight vector corresponding to the class intent is used for summing the denominator in the softmax normalization. Indicates transpose. For the first The bias term corresponding to the class intent, For the first The bias term corresponding to the class intent is used for summing the denominator in the softmax normalization; Based on the intent recognition results, an extended query is performed along the relational path in the knowledge graph to retrieve contextual information including prerequisite steps, dependent parameters, and precautions, forming the hard cue vector.

[0010] Furthermore, the fully deterministic beam search decoding algorithm specifically includes: S31: Establish a three-layer constraint rule system, including a syntax constraint layer, a semantic constraint layer, and a security constraint layer; The syntax constraint layer uses a regular expression template library to store the standard format of each instruction and establishes a mapping table from instruction type to regular expression for format matching. The semantic constraint layer describes the logical relationships between instructions by establishing an instruction dependency matrix, which includes mandatory dependencies, prohibited dependencies, and conditional dependencies. At the same time, it constructs a device state transition table to record the impact of instructions on the device state. The security constraint layer establishes a parameter security range table, defines a safe numerical range for each configurable parameter, and designs a cumulative risk calculator using a risk accumulation function. Calculate the overall risk value of the instruction sequence, where For the first Weighting factor of each instruction Its basic risk value, The attenuation coefficient is... The time interval between instructions; S32: In each decoding step of the model, based on the current generation context and the state of the three-layer constraint rule system, dynamically construct a set of candidate words that satisfy the constraints, forming a candidate word whitelist; perform a cascade check of the three-layer constraints on each candidate word in the whitelist, and calculate its constraint satisfaction probability: ; in, Candidate words, This represents the current constraint state. This refers to the preceding semantic state. For a set of safety parameters, To constrain the probability of satisfaction, Let be the probability that the security constraints are satisfied, representing the probability that a candidate word satisfies the security constraints; only if > The vocabulary was preserved. To constrain the probability threshold, only words whose probability of satisfying the constraint is greater than this threshold will be retained; S33: The candidate words that pass the inspection are ranked using a completely deterministic scoring function, which is defined as follows: ; in, The original probabilities of the language model. Rank the words in alphabetical order. For corpus frequency, To constrain priorities, The weighting coefficients are satisfied. ; S34: The generated candidate instruction sequence is verified through a three-stage serial verification pipeline, including: The first stage is syntax integrity verification: each instruction is matched with the predefined template of the syntax constraint layer to verify the parameter data type and automatically correct formatting issues; The second stage of semantic logic verification involves checking instruction preconditions and conflicts based on the instruction dependency matrix of the semantic constraint layer, and simulating execution using the device state transition table to check the rationality of state transitions. The third stage of security assessment and verification involves verifying all parameter values ​​using the parameter security interval table of the security constraint layer and calculating the comprehensive verification confidence level of the instruction sequence. ; in, For the first The confidence level of the validation at each stage. For the corresponding weight index; only when hour, The instruction sequence must pass verification if it meets the minimum verification confidence threshold. S35: When an error is detected during verification, an automatic error repair process is initiated, the process including: Establish an error pattern knowledge base to record common error types and their characteristics, and use a pattern matching algorithm to identify error types, including parameter out of range, instruction dependency conflict, and syntax error. Following the principle of minimum backtracking, the backtracking cost function is defined as: ; in, For the number of backtracking steps, The step penalty coefficient, For the first The generation complexity of the step, For its weight, As a cost of context loss, This is the context importance coefficient; Based on the error type, select the backtracking position that minimizes the cost function and execute a targeted repair strategy: For parameter out-of-range errors, try adjusting the parameter value to the boundary value of the safe range or find an equivalent alternative parameter combination; for instruction conflict errors, analyze the priority and timing relationship of conflicting instructions, retain high-priority instructions and delete or rearrange low-priority conflicting instructions, and insert necessary intermediate state transition instructions to ensure a smooth transition of device state; for syntax errors, automatically complete missing components and correct the format according to the syntax template.

[0011] The beneficial technical effects of this invention are as follows: First, this invention is specifically designed for the special needs of the electronic test and measurement field. It solves the data privacy protection problem that existing technologies cannot handle by using an innovative three-level conditional diffusion model federated learning architecture. This enables multiple testing institutions to collaboratively train the model without sharing sensitive data, whereas existing technologies are only suitable for centralized training scenarios of a single institution. Furthermore, the cue vectors generated by the conditional diffusion model have stronger adaptability.

[0012] Secondly, this invention innovatively designs a hierarchical retrieval enhancement generation method for heterogeneous documents, which can handle the structural differences of operation manuals from different manufacturers and solve the problem of text discontinuity, enabling rapid adaptation to new devices. In contrast, existing technologies lack specialized processing capabilities for heterogeneous documents and cannot effectively support the instruction generation needs of diverse devices.

[0013] Finally, this invention resolves the fundamental contradiction between the probabilistic generation of large models and the rigorous requirements of programmable instructions through a deterministic generation mechanism that satisfies constraints, ensuring the uniqueness and absolute correctness of generated instructions. In contrast, the probabilistic generation methods of existing technologies cannot meet the strict requirement that test instructions must not have any deviation. Attached Figure Description

[0014] Figure 1 This is a schematic diagram of the programmable instruction generation method based on large model federated prompts for fine-tuning in this invention; Detailed Implementation

[0015] The specific embodiments of the present invention will be further described below with reference to specific examples: A method for generating programmable instructions based on large-model federated prompts for fine-tuning, such as Figure 1 As shown, specifically: In the fine-tuning phase of the large-scale model in the vertical domain, the system first establishes a federated learning network among multiple testing institutions. Each participant fine-tunes the pre-trained model based on its local test instruction dataset. This invention employs a cue-based fine-tuning strategy to adapt the pre-trained large-scale model to the domain. Unlike traditional learnable cue vectors, this invention uses a three-level conditional diffusion model (device layer, task layer, instruction layer) combined with input data to generate cue vectors. During training, the pre-trained large-scale model remains frozen, and only the local conditional diffusion model is updated. After a certain number of local fine-tuning rounds, each client uploads the diffusion model parameters to the federated server. The server uses a hierarchical weighted mechanism to aggregate the diffusion models at different levels, with weights dynamically adjusted based on data distribution similarity and performance contribution. The aggregated global diffusion model is then distributed to each client to begin a new round of training until the predetermined number of rounds is reached.

[0016] Specifically, in the federated prompting fine-tuning phase, a federated learning network is established, consisting of a central server and multiple clients. Each client represents a testing organization and has its own local instruction dataset. These datasets contain actual test cases with different device models, test tasks, and instruction formats. The federated server is responsible for global model aggregation, parameter distribution, and training coordination, but does not store any original training data. The clients are local nodes of each testing organization, maintaining private datasets and local model parameters.

[0017] The central server first randomly initializes the global parameters of a multi-level conditional diffusion model and distributes the initial model to each client. Each client receives the same initial model parameters as the starting point for local training. Each client, based on its local dataset, keeps the pre-trained large model parameters frozen and generates cue vectors through the conditional diffusion model to update the model. Using local device information, task descriptions, and instruction requirements as input conditions, the multi-level conditional diffusion model is trained to generate cue vectors. The training process employs a standard diffusion model training paradigm, adding noise through forward diffusion and then learning denoising capabilities through reverse diffusion. After training, each client uploads the trained model parameters to the central server. The central server uses a hierarchical weighted aggregation mechanism, weighting and aggregating the diffusion model parameters at each level based on the similarity of data distribution and model performance contribution of each client at each level. This yields an updated global multi-level conditional diffusion model, which is then distributed to each client for multiple rounds of iterative training until the model converges. S2: In the reasoning generation stage, user test requests are received; based on the user test requests, relevant contextual information is retrieved from the pre-built device document knowledge graph through intent-driven structured query to generate hard cue vectors; the user test requests and the retrieved contextual information are used as conditions and input into the multi-level conditional diffusion model obtained through federated training, and a deterministic dynamic soft cue vector is generated by fixing the initial noise seed and using a deterministic sampling strategy for reverse diffusion; this cue vector, combined with the user text embedding and the context hard cue vector, guides the pre-trained large model to generate programmable instructions; the encoded embedding of the user test requests, the hard cue vector, and the dynamic soft cue vector are input into the pre-trained large model, and a candidate programmable instruction sequence is generated using a fully deterministic bundle search algorithm; the candidate programmable instruction sequence is serially verified (syntactic structure verification, semantic logic verification, and security verification) to ensure the accuracy, completeness, and security of the output instructions; for instructions that fail verification, backtracking correction is performed according to the minimum backtracking principle, and standardized programmable instructions that can be directly used for device control are output.

[0018] Specifically, the multi-level conditional diffusion model comprises a top-down, conditionally cascaded three-layer structure: a device layer, a task layer, and an instruction layer. The output of the device layer serves as a strong constraint passed to the task layer, while the structured representation of the task layer guides the specific generation of the instruction layer. Structurally, the three-layer diffusion model is based on an improved U-Net backbone network. The overall network adopts the classic encoder-bottleneck-decoder architecture, but incorporates conditional information processing and hierarchical feature learning mechanisms into each component. The encoder part contains six downsampled residual blocks, which integrate diffusion time-step information into the feature representation through a temporal embedding injection layer. The temporal embedding is generated using sinusoidal positional encoding and then mapped to a temporal representation matching the feature dimension through two fully connected layers. The mathematical expression is: ; in For sinusoidal position coding function, , Learnable parameter matrix. The bottleneck layer employs a multi-head self-attention mechanism to handle global dependencies, while introducing a conditional cross-attention module to achieve deep fusion of conditional information. The decoder adopts a symmetrical upsampling structure and includes standard skip connections. The forward propagation process of the entire network can be represented as: ; The device-layer diffusion model generates device-aware prompt features based on the input heterogeneous device attribute information. It employs a U-Net architecture and integrates a multimodal conditional coding subnetwork to process the heterogeneous device attribute information. This subnetwork includes a discrete attribute coding branch using a learnable embedding table to handle classification information such as device model, manufacturer, and interface type; a continuous attribute coding branch using positional coding and Fourier feature transform to handle frequency range and precision values; and a structured attribute coding branch using a graph neural network to handle hierarchical configuration information. The outputs of these three branches are integrated into a device conditional vector through a gating fusion mechanism. The formula for its calculation is: ; in, It is the sigmoid activation function. For the gated weight matrix, Represents element-wise product. The output vector of the discrete attribute encoding branch. The output vector for encoding branches of continuous attributes. The output vector of the structured attribute encoding branch. This is a direct concatenation of the three branch vectors; The residual block of the U-Net architecture in the device layer integrates an adaptive feature modulation layer. This modulation layer dynamically adjusts the statistical properties of the feature representation based on the device condition vector through conditional batch normalization. Its mathematical form is as follows: ; in and The scaling and offset parameters are predicted by device conditions, enabling the network to dynamically adjust the feature processing strategy according to the characteristics of different devices, thus realizing device-aware feature learning. For conditionally batch normalized output, For input features, The mean, Standard deviation; The device-layer diffusion model also introduces a device constraint-aware attention mechanism, incorporating device compatibility constraints into the self-attention calculation process to ensure that the generated feature representations conform to the physical limitations and operational specifications of the device. Its calculation formula is as follows: ; in, This is a mask matrix constructed based on device constraints, used to mask incompatible feature interactions. For querying the matrix, The key matrix, Let be the dimension of the key vector. For value matrices, This is the output of the attention mechanism.

[0019] The task-layer diffusion model employs a Transformer-Diffusion hybrid architecture and includes a task-dependent graph attention network to handle both the sequential nature of the test tasks and their graph-structure dependencies. The encoder part of the network uses an improved Graph Transformer structure, with each Transformer layer containing a standard self-attention module and a newly added graph-structure attention module. The graph-structure attention module specifically handles dependencies between tasks, and its graph attention calculation process considers the partial order constraints of task execution; the calculation formula is as follows: ; in, The task-dependent instruction function allows attention interactions only between task pairs that have a dependency relationship. For learnable query transformation weight matrix, The learnable key transformation weight matrix, Transform the weight matrix to learnable values. and The first and Feature representation vectors of each task node The output of the graph attention mechanism represents the first... The task node for the first Attention-weighted features of each task node; The task layer achieves the collaborative generation of task semantics and structural information through a dual-space joint diffusion mechanism. The diffusion process is carried out simultaneously in the feature space and the graph space. The diffusion in the feature space follows a standard Gaussian Markov process, while the diffusion in the graph space is achieved through a graph Laplace diffusion kernel. ; in The Laplace matrix of the task dependency graph. For time step Graph structure; The instruction-level diffusion model achieves the finest syntax-level generation control, embedding the abstract syntax tree (AST) structure of program-controlled instructions into the diffusion process. It employs a tree-structure-aware diffusion network to generate grammatically correct instructions. Its encoder integrates Tree-LSTM and Transformer; Tree-LSTM handles the syntax tree structure of the instructions, while Transformer handles the serialization representation. The two exchange information through a structure-sequence dual attention mechanism. ; in, The output representation of the structure-sequence dual attention mechanism is a comprehensive feature vector that integrates sequence information and tree structure information. For the serialization encoding of program control instructions, Structured encoding of the Abstract Syntax Tree (AST) (preserving the hierarchy and dependencies of instructions). This represents a vector concatenation operation. For sequence-to-tree attention function, For the attention function from tree to sequence; The diffusion process of the instruction layer adopts a diffusion variant of the masked language model. Based on standard continuous diffusion, a discrete token diffusion mechanism is introduced. Differentiable diffusion of discrete tokens is achieved through Gumbel-Softmax reparameterization, and its distribution is as follows: ; in, The temperature parameter is dynamically adjusted with the diffusion time step. This is the Gumbel noise distribution function, used to generate random noise with a Gumbel distribution, making the discrete sampling process differentiable. Let be the conditional probability distribution for the backdiffusion process, representing the probability of predicting the state at time step t−1 from the state at time step t. Let be the predicted probability distribution (prior distribution) at time step t−1.

[0020] Specifically, in the hierarchical weighted aggregation mechanism, for the first... Layer diffusion model, the first Aggregate weight of each client Calculated dynamically using the following formula: ; in, Indicates the first The client in the first The model parameters corresponding to the layer, Indicates the global model at the 1st The model parameters corresponding to the layer, The similarity of the training data distribution is approximately reflected by the cosine similarity between the client-side model parameters and the global model parameters. The performance contribution is represented by the loss value of the local validation set reported by the client and the number of training samples, and the inverse of the loss weighted by the number of samples is used as the performance metric. This refers to the temperature parameter.

[0021] After aggregation, the updated global diffusion model is redistributed to each client. The system determines whether training has converged by monitoring the performance of the global model on the validation task. If the performance improvement is less than a preset threshold or the maximum number of iterations is reached, training stops; otherwise, the next round of federated training continues.

[0022] Specifically, the hierarchical retrieval enhancement generation method for heterogeneous documents designs a document structure-aware multi-granularity representation learning framework. Through a document structure parsing module, it automatically identifies structured elements in the operation manual, such as chapter levels, step sequences, parameter tables, and dependencies, and constructs a corresponding document knowledge graph. In the knowledge graph, each node represents a semantic unit, and edges represent logical relationships between units. The system establishes multi-level document representations at the lexical, sentence, paragraph, and chapter levels. During the retrieval phase, structured query expansion technology is employed, and retrieval results are expanded through a dependency propagation mechanism, ultimately generating coherent textual contextual hints to guide the large model in generating accurate program control instruction sequences. The method for constructing the device operation knowledge graph and generating hard hint vectors specifically includes the following steps: S21: First, establish a unified heterogeneous document processing pipeline, using deep learning technology to automatically identify and extract structured information from documents of different formats. Through a layout analysis model based on convolutional neural networks, parse device operation manuals in PDF and Word formats, automatically detecting different types of content blocks such as text areas, table areas, image areas, and title areas on the document page. For table structures and operation steps, accurately segment consecutive operation steps by recognizing linguistic markers such as step numbers, key verbs, and temporal connectors, while also labeling the type of each step. S22: Based on the parsing results, a multi-level knowledge graph oriented towards the operation process is constructed, reorganizing the scattered information fragments in the document into a graph structure representation with clear semantic relationships. The knowledge graph includes six core types: operation step nodes, parameter configuration nodes, device status nodes, condition judgment nodes, exception handling nodes, and result verification nodes. The edge relationship types cover temporal execution relationships, conditional branch relationships, parameter dependency relationships, exception handling relationships, state transition relationships, and reference relationships. To solve the problem of discontinuous text blocks caused by document layout and line breaks, physical continuity edges are introduced to connect text blocks that are physically separated in the original document due to line breaks, columns, or page breaks but logically belong to the same semantic unit. S23: To address the common issue of discontinuous text blocks in user manuals, the system uses a random walk algorithm to expand the search along physical continuity edges on the knowledge graph. This automatically identifies continuous text blocks separated in the original document due to formatting issues such as line breaks, column breaks, and table insertions, discovering and restoring semantically continuous content fragmented by document layout. After retrieving multiple scattered text fragments, the system constructs a physical adjacency graph between fragments by analyzing their physical location information in the original document. Heuristic rules are then used to connect the text, including: hierarchical judgment rules based on the same indentation level and font style, sequence matching rules based on consecutive numbering patterns, and sentence integrity judgment rules based on the punctuation at the end of the preceding sentence and the beginning character of the following sentence. The connection process is supplemented by semantic embedding similarity verification and contextual logical consistency checks. Specifically, the process is as follows: First, the same indentation level recognition rule is used to determine whether text blocks belong to the same hierarchical structure. When two text blocks have the same left margin pixel value and the same font size, the possibility of connection is given priority. Second, the number sequence matching rule is used to identify the segmented ordered list. The continuous numbering patterns such as "1.", "2.", "Step 1", and "Step 2" are detected by regular expressions, and text blocks with continuous numbers and physical distances within a preset threshold are automatically connected. Then, the sentence truncation problem is handled by the punctuation integrity judgment rule. When the previous text block ends with a comma, semicolon, or conjunction, and the next text block starts with a lowercase letter or is a natural continuation of a sentence, it is determined to be different parts of the same sentence and connected. At the same time, a semantic similarity verification mechanism is used to calculate the semantic embedding similarity of adjacent text blocks. Only text blocks with similarity exceeding a set threshold are physically connected to avoid merging irrelevant content incorrectly. Finally, the context consistency check is used to analyze the grammatical integrity and logical rationality of the connected text. Connection results with grammatical inconsistencies or excessive logical jumps are rolled back to ensure the quality and readability of the reconstructed text.

[0023] S24: Hierarchical Semantic Representation Learning: Text content in the knowledge graph is encoded using a four-layer architecture: lexical, sentence, paragraph, and chapter layers. Each layer focuses on capturing semantic information at different granularities for data encoding and embedding. The lexical layer uses a domain-adaptive pre-trained word vector model to learn accurate semantic representations of specialized vocabulary. The sentence layer uses an improved Sentence-BERT architecture to add an operation intent recognition branch. The paragraph layer uses a hierarchical Transformer encoder to capture the dependencies between operation steps. The chapter layer constructs a global operation flow representation. Information is transferred between layers through a cross-layer attention mechanism, resulting in a fused representation. The calculation is as follows: ; in, For the first Layer representation, For query vector, These are learnable weights; S25: During retrieval enhancement, an intent-driven structured query method is used to analyze the literal semantics of user queries and infer the underlying operational intent. When a user inputs a testing requirement, key entities are first extracted using named entity recognition and mapped to corresponding nodes in the knowledge graph using an entity linking algorithm. Simultaneously, the user's query intent is identified using an intent classification model, with the intent recognition probability calculated using a softmax function. ; in, For the first The learnable weight vector corresponding to the class intent, For the first The learnable weight vector corresponding to the class intent is used for summing the denominator in the softmax normalization. Indicates transpose. For the first The bias term corresponding to the class intent, No. The bias term corresponding to the class intent is used for summing the denominator in the softmax normalization; Based on the intent recognition results, an extended query is performed along the relational path in the knowledge graph to retrieve contextual information including prerequisite steps, dependent parameters, and precautions, forming the hard cue vector.

[0024] Finally, the structured text prompts generated by hierarchical retrieval are combined with the dynamic prompt vectors obtained from federated learning to guide the large model in generating accurate sequences of programmed instructions. The dynamic prompt vectors are embedded into the input layer as soft prompts, providing the model with personalized testing environment adaptation information, while the structured text prompts are directly concatenated into the input sequence as hard prompts, providing the model with clear operational specifications and detailed execution guidance.

[0025] Specifically, the fully deterministic beam search decoding algorithm includes: S31: Establish a three-layer constraint rule system, including a syntax constraint layer, a semantic constraint layer, and a security constraint layer. Each layer of constraints adopts different representation methods and checking mechanisms to ensure the standardization of generated instructions. The syntax constraint layer uses a regular expression template library to store the standard format of each instruction. Each constraint layer uses different representation methods and checking mechanisms to ensure the standardization of the generated instructions and establishes a mapping table from instruction type to regular expression, thereby achieving format matching with O(1) time complexity. The semantic constraint layer describes the logical relationships between instructions by establishing an instruction dependency matrix, where rows represent preceding instructions, columns represent subsequent instructions, and matrix elements represent dependency types, including mandatory dependencies, prohibited dependencies, and conditional dependencies. At the same time, a device state transition table is constructed to record the impact of instructions on the device state. The safety constraint layer establishes a parameter safety range table, defines a safe numerical range for each configurable parameter, and designs a cumulative risk calculator using a risk accumulation function. Calculate the overall risk value of the instruction sequence, where For the first Weighting factor of each instruction Its basic risk value, The attenuation coefficient is... The time interval between instructions is set to ensure that the generated instructions do not damage the device; S32: In each decoding step of the model, the system no longer samples from the complete vocabulary. Instead, based on the current generation context and the state of the three-layer constraint rule system, it dynamically constructs a set of candidate words that satisfy the constraints to ensure the compliance of the generated content, forming a candidate word whitelist. For example, if "VOLT" has already been generated, the next word can only be a number or unit symbol, and the system automatically filters out all other words. For each candidate word in the whitelist, a cascade check of the three-layer constraints is performed, and its constraint satisfaction probability is calculated. ; in, Candidate words, This represents the current constraint state. This refers to the preceding semantic state. For a set of safety parameters, To constrain the probability of satisfaction, Let be the probability that the security constraints are satisfied, representing the probability that a candidate word satisfies the security constraints; only if The vocabulary was preserved. To constrain the probability threshold, only words with a probability greater than this threshold are retained. Any word that violates the constraint is forcibly excluded, and its probability value is set to 0, ensuring that the model cannot select candidates that violate the constraint, thereby preventing the generation of erroneous instructions at the source.

[0026] S33: All randomness is eliminated through a fully deterministic bundle search process, ensuring that the same input produces the same output. The system uses the hash value of the input text as a random seed, ensuring that the same input always produces the same initial state. All operations involving randomness are based on this fixed seed. At each decoding step, the candidate words that pass the inspection are sorted using a fully deterministic scoring function, defined as: ; in, The original probabilities of the language model. Rank the words in alphabetical order. For corpus frequency, To constrain priorities, The weighting coefficients are satisfied. ; S34: The generated candidate instruction sequence is verified through a three-stage serial verification pipeline, including: The first stage is syntax integrity verification: each instruction is matched with the predefined template of the syntax constraint layer through template matching, and the compiled regular expression engine is used for efficient verification to verify whether the parameter data type is correct and automatically correct minor formatting issues such as extra spaces and inconsistent capitalization. The second stage of semantic logic verification involves checking the instruction preconditions and conflicts based on the instruction dependency matrix of the semantic constraint layer, simulating execution using the device state transition table to check the rationality of state transitions, and analyzing whether the parameter settings of different instructions are compatible. The third stage of security assessment and verification involves verifying all parameter values ​​using the parameter security interval table of the security constraint layer and calculating the comprehensive verification confidence level of the instruction sequence. ; in, For the first The confidence level of the validation at each stage. For the corresponding weight index; only when hour, The instruction sequence must pass verification if it meets the minimum verification confidence threshold. S35: When an error is detected during verification, an automatic error correction process is initiated to ensure the correctness of the final output. The process includes: Establish an error pattern knowledge base to record common error types and their characteristics, and use a pattern matching algorithm to identify error types, including parameter out of range, instruction dependency conflict, and syntax error. Following the principle of minimum backtracking, the backtracking cost function is defined as: ; in, For the number of backtracking steps, The step penalty coefficient, For the first The generation complexity of the step, For its weight, As a cost of context loss, This is the context importance coefficient; Based on the error type, the system selects the backtracking position that minimizes the cost function and executes a targeted repair strategy: For parameter out-of-range errors, it attempts to adjust the parameter value to the boundary value of the safe range. If the boundary value does not meet the functional requirements, it searches for functionally equivalent alternative parameter combinations. For example, when the voltage setting exceeds the device's tolerance range, the system automatically searches for current and impedance parameter combinations that can achieve the same test effect. For command conflict errors, it analyzes the priority and timing relationship of conflicting commands, retains high-priority commands and deletes or rearranges low-priority conflicting commands, and inserts necessary intermediate state transition commands to ensure a smooth transition of device states. For syntax errors, it automatically completes missing components and corrects the format according to the syntax template, and unifies the capitalization and delimiter format of commands.

[0027] During the backtracking process, effective contextual information is maintained to avoid losing correctly generated content. Simultaneously, the path and method of each repair are recorded to build a repair experience library for future reference. The system dynamically adjusts constraints based on the cause of the error. For example, if a parameter combination causes a conflict, corresponding prohibition constraints are automatically added. A constraint learning mechanism is used to learn new constraint rules from errors, continuously improving the completeness and accuracy of the constraint rule library.

[0028] Of course, the above description is not intended to limit the present invention, and the present invention is not limited to the examples given above. Any changes, modifications, additions or substitutions made by those skilled in the art within the scope of the present invention should also fall within the protection scope of the present invention.

Claims

1. A method for generating programmable instructions based on large-model federated hints for fine-tuning, characterized in that, Includes the following steps: S1: Federated Hints Fine-tuning Phase, establishing a federated learning network that includes a central server and multiple clients; The central server initializes a multi-level conditional diffusion model and distributes it to each client. Each client, based on its local dataset, keeps the parameters of the pre-trained large model frozen and uses local device information, task description, and instruction requirements as input conditions to train the multi-level conditional diffusion model to generate prompt vectors. After training is completed, each client uploads the trained model parameters to the central server. The central server adopts a hierarchical weighted aggregation mechanism, which performs weighted aggregation of the diffusion model parameters at each level based on the similarity of data distribution and the contribution of each client to model performance at each level, to obtain an updated global multi-level conditional diffusion model, which is then distributed to each client for multiple rounds of iterative training until the model converges. S2: In the inference generation stage, user test requests are received; based on the user test requests, relevant contextual information is retrieved from the pre-built device document knowledge graph through intent-driven structured query to generate hard cue vectors; the user test requests and the retrieved contextual information are used as conditions and input into the multi-level conditional diffusion model obtained through federated training, and a deterministic dynamic soft cue vector is generated by fixing the initial noise seed and using a deterministic sampling strategy for reverse diffusion; the encoded embedding of the user test requests, the hard cue vectors, and the dynamic soft cue vectors are jointly input into the pre-trained large model, and a candidate programmable instruction sequence is generated using a fully deterministic bundle search algorithm; the candidate programmable instruction sequence is serially verified and backtracked for correction, and standardized programmable instructions are output.

2. The method for generating programmable instructions based on large-model federated prompts for fine-tuning according to claim 1, characterized in that, The multi-level conditional diffusion model includes a three-layer structure with conditional cascading from top to bottom, comprising a device layer, a task layer, and an instruction layer. The device layer diffusion model is used to generate device-aware prompt features based on the input heterogeneous device attribute information. It adopts the U-Net architecture and integrates a multimodal conditional coding sub-network. This sub-network includes a discrete attribute coding branch for processing device model, manufacturer, and interface type; a continuous attribute coding branch for processing frequency range and precision value; and a structured attribute coding branch for processing hierarchical configuration information. The outputs of the three branches are integrated into a device condition vector through a gating fusion mechanism. The formula for its calculation is: ； in, It is the sigmoid activation function. For the gated weight matrix, Represents element-wise product. The output vector of the discrete attribute encoding branch. The output vector for encoding branches of continuous attributes. The output vector of the structured attribute encoding branch. This is a direct concatenation of the three branch vectors; The residual block of the U-Net architecture in the device layer integrates an adaptive feature modulation layer, which dynamically adjusts the statistical properties of the feature representation based on the device condition vector through conditional batch normalization. ； in and The scaling and offset parameters are predicted by the device conditions. For conditionally batch normalized output, For input features, The mean, Standard deviation; The device-layer diffusion model also introduces an attention mechanism for device constraint awareness, the calculation formula of which is: ； in, The mask matrix is ​​constructed based on device constraints. For querying the matrix, The key matrix, Let be the dimension of the key vector. For value matrices, This is the output of the attention mechanism.

3. The method for generating programmable instructions based on large-model federated hints for fine-tuning according to claim 1, characterized in that, The task-layer diffusion model adopts a Transformer-Diffusion hybrid architecture and includes a task-dependent graph attention network. Its graph attention calculation process considers the partial order constraints of task execution, and the calculation formula is as follows: ； in, Task depends on indicator functions, For learnable query transformation weight matrix, For learnable key transformation weight matrix, Transform the weight matrix to learnable values. and The first and Feature representation vectors of each task node For the output of the graph attention mechanism, let represent the th The task node for the first Attention-weighted features of each task node; The task layer employs a dual-space joint diffusion mechanism to simultaneously perform the diffusion process in the feature space and graph space, where the graph space diffusion is achieved through a graph Laplacian diffusion kernel: ； in, The Laplace matrix of the task dependency graph. For time step Graph structure; The instruction layer diffusion model embeds the abstract syntax tree structure of program-controlled instructions into the diffusion process, employs a tree-structure-aware diffusion network, and its encoder integrates Tree-LSTM and Transformer, exchanging information through a structure-sequence dual attention mechanism. ； in, The output representation of the structure-sequence dual attention mechanism is a comprehensive feature vector that integrates sequence information and tree structure information. For the serialization encoding of program control instructions, Structured encoding for abstract syntax trees, This represents a vector concatenation operation. For sequence-to-tree attention function, For the attention function from tree to sequence; The diffusion process of the instruction layer adopts a diffusion variant of the masked language model, and achieves differentiable diffusion of discrete tokens through Gumbel-Softmax reparameterization, with the following distribution: ； in, For temperature parameters, This is the Gumbel noise distribution function, used to generate random noise with a Gumbel distribution, making the discrete sampling process differentiable. Let be the conditional probability distribution for the backdiffusion process, representing the probability of predicting the state at time step t−1 from the state at time step t. Let be the predicted probability distribution at time step t−1.

4. The method for generating programmable instructions based on large-model federated hints for fine-tuning according to claim 1, characterized in that, In the aforementioned hierarchical weighted aggregation mechanism, for the first... Layer diffusion model, the first Aggregate weight of each client Calculated dynamically using the following formula: ； in, Indicates the first The client in the first The model parameters corresponding to the layer, Indicates the global model at the 1st The model parameters corresponding to the layer, The similarity of the training data distribution is approximately reflected by the cosine similarity between the client-side model parameters and the global model parameters. The performance contribution is represented by the loss value of the local validation set reported by the client and the number of training samples, and the inverse of the loss weighted by the number of samples is used as the performance metric. This refers to the temperature parameter.

5. The method for generating programmable instructions based on large-model federated hints for fine-tuning according to claim 1, characterized in that, The construction of the device operation knowledge graph and the generation of the hard cue vectors include the following steps: S21: Using a layout analysis model based on convolutional neural networks, the device operation manuals in PDF and Word formats are parsed, and chapter titles, operation step sequences, parameter tables, and dependencies are automatically identified. S22: Based on the parsing results, construct a knowledge graph with operation step nodes, parameter configuration nodes, device status nodes, condition judgment nodes, exception handling nodes, and result verification nodes as core types, and time-series execution relationships, conditional branch relationships, parameter dependency relationships, exception handling relationships, state transition relationships, and reference relationships as edge relationship types; introduce physical continuity edges to connect text blocks that are physically separated in the original document due to line breaks, column breaks, and page breaks but logically belong to the same semantic unit; S23: After retrieving multiple scattered text fragments, a physical adjacency graph between fragments is constructed by analyzing the physical location information of the fragments in the original document, and heuristic rules are used to connect the text. The rules include: hierarchical judgment rules based on the same indentation level and font style, sequence matching rules based on consecutive numbering patterns, and sentence integrity judgment rules based on the punctuation at the end of the previous sentence and the character at the beginning of the next sentence. The connection process is supplemented by semantic embedding similarity verification and contextual logic consistency checks. S24: Hierarchical Semantic Representation Learning: The text content in the knowledge graph is encoded using a four-level architecture: lexical, sentence, paragraph, and chapter levels. The encoders at each level fuse information through a cross-level attention mechanism, ultimately resulting in a fused representation. The calculation is as follows: ； in, For the first Layer representation, For query vector, These are learnable weights; S25: When a user inputs a testing request, key entities are first extracted using named entity recognition and mapped to corresponding nodes in the knowledge graph; simultaneously, the user's query intent is identified using an intent classification model, with the intent recognition probability calculated using the softmax function. ； in, For the first The learnable weight vector corresponding to the class intent, For the first The learnable weight vector corresponding to the class intent is used for summing the denominator in the softmax normalization. Indicates transpose. For the first The bias term corresponding to the class intent, For the first The bias term corresponding to the class intent is used for summing the denominator in the softmax normalization; Based on the intent recognition results, an extended query is performed along the relational path in the knowledge graph to retrieve contextual information including prerequisite steps, dependent parameters, and precautions, forming the hard cue vector.

6. The method for generating programmable instructions based on large-model federated hints for fine-tuning according to claim 1, characterized in that, The fully deterministic beam search decoding algorithm specifically includes: S31: Establish a three-layer constraint rule system, including a syntax constraint layer, a semantic constraint layer, and a security constraint layer; The syntax constraint layer uses a regular expression template library to store the standard format of each instruction and establishes a mapping table from instruction type to regular expression for format matching. The semantic constraint layer describes the logical relationships between instructions by establishing an instruction dependency matrix, including mandatory dependencies, prohibited dependencies, and conditional dependencies. It also constructs a device state transition table to record the impact of instructions on device states. The security constraint layer establishes a parameter security interval table to define a safe numerical range for each configurable parameter and designs a cumulative risk calculator using a risk accumulation function. Calculate the overall risk value of the instruction sequence, where For the first Weighting factor of each instruction Its basic risk value, The attenuation coefficient is... The time interval between instructions; S32: In each decoding step of the model, based on the current generation context and the state of the three-layer constraint rule system, dynamically construct a set of candidate words that satisfy the constraints, forming a candidate word whitelist; perform a cascade check of the three-layer constraints on each candidate word in the whitelist, and calculate its constraint satisfaction probability: ； in, Candidate words, This represents the current constraint state. This refers to the preceding semantic state. For a set of safety parameters, To constrain the probability of satisfaction, Let be the probability that the security constraints are satisfied, representing the probability that a candidate word satisfies the security constraints; only if > The vocabulary was preserved. To constrain the probability threshold, only words whose probability of satisfying the constraint is greater than this threshold will be retained; S33: The candidate words that pass the inspection are ranked using a completely deterministic scoring function, which is defined as follows: ； in, The original probabilities of the language model. Rank the words in alphabetical order. For corpus frequency, To constrain priorities, The weighting coefficients are and satisfy the following conditions: ; S34: The generated candidate instruction sequence is verified through a three-stage serial verification pipeline, including: The first stage is syntactic integrity verification: each instruction is matched against the predefined template of the syntactic constraint layer to verify parameter data types and automatically correct formatting issues. The second stage is semantic logic verification: instruction preconditions and conflicts are checked against the instruction dependency matrix of the semantic constraint layer, and execution is simulated using a device state transition table to check the rationality of state transitions. The third stage is security assessment verification: all parameter values ​​are verified using the parameter security interval table of the security constraint layer, and the overall verification confidence of the instruction sequence is calculated. ； in, For the first The confidence level of the validation at each stage. For the corresponding weight index; only when hour, The instruction sequence must pass verification if it meets the minimum verification confidence threshold. S35: When an error is detected during verification, an automatic error repair process is initiated, the process including: Establish an error pattern knowledge base to record common error types and their characteristics, and use a pattern matching algorithm to identify error types, including parameter out of range, instruction dependency conflict, and syntax error. Following the principle of minimum backtracking, the backtracking cost function is defined as: ； in, For the number of backtracking steps, The step penalty coefficient, For the first The generation complexity of the step, For its weight, As a cost of context loss, This is the context importance coefficient; Based on the error type, select the backtracking position that minimizes the cost function and execute a targeted repair strategy: For parameter out-of-range errors, try adjusting the parameter value to the boundary value of the safe range or find an equivalent alternative parameter combination; for instruction conflict errors, analyze the priority and timing relationship of conflicting instructions, retain high-priority instructions and delete or rearrange low-priority conflicting instructions, and insert necessary intermediate state transition instructions to ensure a smooth transition of device state; for syntax errors, automatically complete missing components and correct the format according to the syntax template.

Images