Annoated multi-intention semantic parsing method, system and device

Abstract

The application discloses a kind of unlabeled multi-intention semantic analysis method, system and device, method includes: from target field obtains intent set and slot set, and constructs intent slot specification tuple;Subsequently, based on preset slot library, reverse progressive skeleton generation is carried out, and natural language query sentence satisfying constraint condition is generated;Through vector similarity calculation and multidimensional quality evaluation, duplicate and quality filtering are carried out to the synthesized sentence;A plurality of semantic analysis models are used to independently analyze the sentence, and high confidence samples are screened through cross consensus verification;For the sample with analysis difference, introduce arbitration model to resolve conflict, obtain final labeling result;Supervised fine-tuning is carried out to semantic analysis model using the high-quality synthesized dataset constructed, and model self-distillation optimization is realized.The scheme realizes zero artificial labeling, effectively eliminates LLM illusion, realizes strict semantic alignment, effectively improves small parameter model performance and generalization ability.

Description

Technical Field

[0001] This invention relates to the fields of natural language processing and dialogue artificial intelligence technology, and more specifically, to a method, system, and apparatus for unlabeled multi-intent semantic parsing based on collaborative self-distillation. Background Technology

[0002] In task-oriented dialogue systems, spoken language understanding (SLU) plays the role of the "brain." Its core task is to transform the user's natural language expression into structured data, namely, extracting intents and slots. Traditional SLU systems typically assume that a sentence contains only a single intent. However, in real-world interaction scenarios such as in-vehicle voice control, intelligent customer service, and smart homes, users often express multiple intents simultaneously (i.e., multi-intent SLU).

[0003] Currently, the academic and industrial communities facing the following technical bottlenecks in solving the multi-intent SLU problem are: 1. Traditional joint neural networks (such as Slot-gated RNNs) or supervised fine-tuning methods based on pre-trained models (such as fine-tuning BERT) heavily rely on large-scale, high-quality manually labeled data. Because multi-intent sentences are usually long and have complex syntactic structures, labeling fine-grained slot boundaries is extremely costly, time-consuming, and prone to errors due to inconsistencies in manual labeling.

[0004] 2. In recent years, many studies have attempted to utilize general-purpose large language models for zero-shot inference to completely eliminate the need for manual annotation. However, large language models are essentially divergent autoregressive text generators. When faced with the "strictly structured semantic parsing" required by SLU tasks, they often suffer from severe "hallucinations"—such as fabricating slot values ​​out of thin air or failing to strictly align the extracted slot values ​​with the character boundaries in the original text, leading to parsing format errors or information omissions. Consequently, they cannot be directly applied to downstream business systems with extremely high stability requirements. Summary of the Invention

[0005] In view of this, the purpose of this invention is to provide a method, system, and apparatus for unlabeled multi-intent semantic parsing based on collaborative self-distillation, to solve the technical problems of existing technologies that heavily rely on expensive manually labeled data, and the ease with which large-scale zero-shot inference can produce illusions and is difficult to achieve strict alignment. Specifically, this invention provides the following technical solutions: On the one hand, the present invention provides an unlabeled multi-intent semantic parsing method, comprising the following steps: Step S1: Obtain intent and slot specifications from the target domain and perform intent-slot sampling.

[0006] Further, step S1 specifically includes: Step S11: Obtain the domain ontology of the target application domain and define a complete set of intents. and slot tag collection ; Step S12: For each sample to be synthesized, from the intent set and slot tag collection Multiple intentions and multiple slot labels are randomly selected and combined to form an initial canonical tuple.

[0007] Step S2: Using a multi-value sampling method and a preset slot library, a set of large language models is used to perform reverse progressive skeleton generation to synthesize a natural language query statement containing multiple intents. Furthermore, the specific generation process of step S2 is achieved through the following sub-steps and formula constraints: Step S21: Construct a preset slot library The preset slot library contains a domain entity dictionary pre-filled for each slot label; and introduces a multi-value sampling method (MVS) to allow the same slot label in a canonical tuple to be mapped to multiple different specific entity values; Step S22: Large language model based on canonical tuples and slot library This generates a multi-intent topic overview and defined slot key-value pairs. For parameters... Generative large language model The skeleton generation process is represented as follows: ,in, Indicates certainty Each slot key-value pair For specific entity values, For the corresponding slot label; Step S23: Using the sampled intent, the above-mentioned multi-intent semantic overview, and slot key-value pairs as hard constraints, instruct the large language model. Synthesize the final fluent natural language query statement The process is represented as: .

[0008] Step S3: Based on vector embedding similarity and multi-dimensional scoring, the synthesized natural language query statement is deduplicated and quality filtered; further, step S3 specifically includes: Step S31, Sentence Vector Deduplication: Using a sentence vector model to deduplicat candidate query statements. Encode as feature vector Combine it with the samples already stored in the qualified sample pool Statement vectors in Cosine similarity calculations are performed, and duplicates are retained only if the following deduplication formula is satisfied: .in, Set a preset similarity deduplication threshold; Step S32, Judge Model Quality Scoring: Introduce a large language model for judges with more parameters than the generator model, and evaluate it from the set of dimensions. (Including four dimensions: fluency, naturalness, semantic richness, and logical coherence) for statements Scoring will be conducted. The scoring formula is as follows: in, For statement In dimensions Each section score is out of 5 points. The total score... When a preset threshold is reached (e.g., 3.0 points), the statement is deemed to be a qualified filter statement.

[0009] Step S4: Control the set of large language models to independently perform semantic parsing on the filtered query statements, and perform cross-model consensus verification to extract high-confidence samples; Step S41: Disable the initial label constraints and filter out qualified query statements. The inputs are fed into the first and second language models respectively, requiring the two models to independently perform zero-shot intent extraction and slot extraction. Step S42: Obtain the parsing results of the first large language model. The analysis results of the second largest language model ;in Represents a set of intentions. Represents a set of key-value pairs for a slot; Step S43: Execute the cross-model consensus verification mechanism: Strictly check whether the outputs of the two models meet the consistency conditions. and If the conditions are met, a consensus is reached, and the statement and its parsing result are retained as a high-confidence sample; otherwise, it is marked as a divergence sample.

[0010] Step S5: For the disagreement samples where no consensus has been reached, a large language model for arbitration and conflict resolution is introduced, and the samples are merged with the high-confidence samples to construct a high-quality synthetic dataset. Step S51: For divergent samples that generate parsing conflicts, combine the original query statement and the initial canonical tuple. First analysis result Second analysis result The full set of valid label definitions are also input into the judge's large language model; Step S52: Control the referee's large language model to perform a comprehensive evaluation, analyze discrepancies and integrate the correct slot boundaries, or re-extract features based on the context to generate a unique optimal parsing label. .

[0011] Step S53, change the statement With optimal parsing labels The samples are bound to arbitration samples and merged with the high-confidence samples obtained in step S4 to form a high-quality synthetic dataset.

[0012] Step S6: Using the high-quality synthetic dataset as a supervisory signal, supervise the fine-tuning of the above pair of large language models to achieve collaborative self-distillation and obtain the target multi-intent semantic parsing model. After obtaining the target multi-intent semantic parsing model, use this model to perform semantic parsing on the target language data.

[0013] Step S61: Convert the high-quality synthetic dataset into an instruction fine-tuning format and extract the multi-intent detection training set and slot filling training set; Step S62: Update the network weights of the large language model using the low-rank adaptive (LoRA) parameter fine-tuning technique; Step S63: Calculate the cross-entropy loss between the output distribution of the large language model and the high-quality synthesized tags using an autoregressive approach and perform backpropagation fine-tuning to complete the knowledge self-distillation from unconstrained generation capability to rigorously structured spoken language parsing capability.

[0014] On the other hand, this invention also provides an unlabeled multi-intent semantic parsing system, comprising: a sampling and constraint module: used to obtain a predefined domain ontology, construct an entity slot library, and perform multi-value sampling to generate canonical tuples; a reverse progressive generation module: connected to two major language model engines, receiving the canonical tuples and slot library constraints, and sequentially generating a semantic draft and a fluent user query statement; a feature filtering module: with built-in vector similarity calculation unit and prompt word scoring unit, using the cosine similarity extreme value algorithm to perform semantic deduplication on the generated query statement and perform multi-dimensional scoring filtering; and a cross-parsing and arbitration module: used to drive the two major language models to independently output parsing results for the retained statements. It performs consistency equation matching; when matching fails, it introduces a referee big language model to output the final arbitration label; self-distillation fine-tuning module: using the fused high-quality arbitration and consensus data, it calculates the loss function and updates the gradient of the basic big language model through a parameter efficient fine-tuning algorithm, and outputs a high-precision multi-intent spoken language understanding model.

[0015] Furthermore, the present invention also provides an unlabeled multi-intent semantic parsing apparatus, which includes a processor, a memory, a communication interface, and a system bus, wherein the memory stores a computer program, and the processor calls the computer program through the system bus to execute the unlabeled multi-intent semantic parsing method as described above.

[0016] Compared with existing technologies, the technical solution of this invention has the following advantages: Completely breaks down data barriers and achieves zero manual annotation: This solution, through its pioneering six-stage collaborative self-distillation framework, transforms the generation capability of large language models into rigorously parsed data, completely replacing the traditional, expensive manual annotation process. Effectively eliminates the LLM illusion and achieves strict semantic alignment: Through innovative "reverse progressive skeleton generation" combined with the hard constraints of the slot bank, the possibility of models fabricating entities out of thin air is limited from the source; coupled with cross-consensus and referee arbitration mechanisms, misaligned and structurally disordered samples are effectively filtered out, ensuring data purity. Achieves performance reversal and generalization for small parameter models: This solution endows small open-source models at the 7B / 8B level with extremely strong multi-intent parsing capabilities. Small models after self-distillation using this framework achieve an overall parsing accuracy improvement of up to 13 times, even surpassing large models with hundreds of bytes of parameters, and also have faster inference speeds and extremely low deployment costs. Attached Figure Description

[0017] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0018] Figure 1 This is a flowchart of a method according to an embodiment of the present invention; Figure 2 This is a diagram illustrating the collaborative self-distillation data construction architecture of an embodiment of the present invention. Figure 3 This is a system logic module diagram according to an embodiment of the present invention; Figure 4 This is a structural diagram of an electronic device according to an embodiment of the present invention. Detailed Implementation

[0019] The present invention will be further illustrated below with reference to the accompanying drawings and specific embodiments. It should be understood that the described embodiments are only a part of the embodiments of the present invention, and not all of them. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative effort are within the scope of protection of the present invention.

[0020] Those skilled in the art should understand that the following specific embodiments or implementation methods are a series of optimized configurations listed to further explain the specific content of the invention. These configurations can be combined or used in conjunction with each other, unless the invention explicitly states that some or a particular embodiment or implementation method cannot be associated with or used in conjunction with other embodiments or implementation methods. Furthermore, the following specific embodiments or implementation methods are merely optimized configurations and are not intended to limit the scope of protection of the invention. The content of this solution will be described below in conjunction with specific embodiments.

[0021] Example 1 Please see Figure 1 This embodiment provides an unlabeled multi-intent semantic parsing method based on collaborative self-distillation. This method does not rely on any manually labeled data and achieves high-precision structured semantic parsing through the collaborative and self-distillation mechanism of Large Language Models (LLMs). The method specifically includes the following steps: Step S1: Obtain intent and slot specifications from the target domain and perform intent-slot sampling.

[0022] Specifically, this step aims to define the task boundary and generate initial constraints. Step S11: Obtain the domain ontology of the target application domain (e.g., intelligent in-vehicle voice assistant, smart home control, etc.). A complete set of intents is predefined manually or by the system. and slot tag collection Step S12: For each sample to be synthesized, according to a preset probability distribution, from the intent set... and slot tag collection Multiple intents (e.g., 2 to 3 intents) and multiple slot labels are randomly selected and combined to form the initial canonical tuple. The introduction of multiple intentions is to simulate the complex spoken language habits of real users.

[0023] The preset probability distribution is preferably a discrete sampling distribution, which can be set according to prior knowledge of the target domain, tag frequency, or business scenario coverage requirements. As a preferred implementation, when there is no prior statistical information, the number of intents can be sampled uniformly within the range of {1, 2, 3}, or a weighted discrete distribution biased towards 2 to 3 intents can be set with multiple intent samples as the target; slot tags can be sampled uniformly without replacement from the slot set. If historical logs or test set statistical information exist in the target domain, a weighted discrete distribution can be set according to the frequency of occurrence of each intent and slot tag, or the sampling weight of low-frequency tags can be increased to ensure that the synthesized samples cover all intents, slots, and their combinations.

[0024] Step S2: Combining multi-value sampling with a preset slot library, reverse progressive skeleton generation is performed using a pair of large language models.

[0025] Since directly generating data from a large model can easily lead to a mismatch between slot entities and text characters (i.e., "illusion"), this embodiment innovatively adopts a "reverse progressive" generation strategy, which specifically includes the following sub-steps: Step S21: Construct a preset slot library The slot library B contains a pre-filled dictionary of real-domain entities for each slot label (e.g., "Artist" corresponds to singer names "AAA, CCC," etc.). To increase the structural complexity of the generated data, a multi-value sampling (MVS) mechanism is introduced, allowing the same slot label in a canonical tuple to be mapped and extracted from the library with multiple different specific entity values ​​(e.g., extracting two different singer names at once). Step S22: Control a pair of generative large language models with completely identical parameters. In this embodiment, two models are used as examples, referred to as the first model and the second model, or collectively as models. The parameters are According to canonical tuples and slot library The specific entity values ​​assigned in the framework are first used to generate a coarse-grained semantic overview and defined slot key-value pairs. The mathematical expression for this skeleton generation process is as follows: .in, Indicates mandatory determination Each slot key-value pair For specific entity values, This corresponds to the slot label. This step, through hard constraints, eliminates the possibility of the model fabricating entities out of thin air later. Step S23: Using the intent, semantic draft, and determined slot key-value pairs obtained in step S22 as hard prompt constraints, the large language model is instructed to synthesize the final fluent, grammatically correct natural language user query. Its formula is expressed as: For example, the generated query statement It could be something like: "Please play CCC's song, and while you're at it, check the weather in Beijing tomorrow." Step S3: Based on vector embedding similarity and multi-dimensional scoring mechanism, deduplication and quality filtering are performed on the synthesized sentences.

[0026] To prevent severe data homogenization and remove low-quality samples with grammatical errors, this embodiment employs a dual filtering method: Step S31: Sentence vector deduplication. A pre-trained sentence embedding model (such as the Sentence-BERT model) is used to deduplicate the newly generated query statements. Encode as a high-dimensional feature vector and compared it with the samples already stored in the qualified sample pool. All historical statement vectors Perform cosine similarity calculation. A statement is only allowed to proceed to the next stage if it meets the following deduplication formula: ,in, The preset similarity threshold can be set to 0.90 in this embodiment. If the maximum similarity exceeds the threshold, it indicates that the sentence pattern already exists and is discarded. Step S32: Introduce a large-scale language model with more parameters and stronger reasoning ability (such as the Qwen2.5-72B model) as a quality evaluator. Evaluate the set of dimensions... For statement Perform independent scoring. If the score is greater than a threshold (e.g., 3 points), the statement is deemed invalid. High-quality natural language sentences are retained. Evaluation dimension set. The evaluation comprises four dimensions: fluency, naturalness, semantic richness, and logical coherence. Further, the scores for each dimension in step S32 can be calculated as follows: The judge's large language model scores the statement to be evaluated based on preset scoring prompts. Specifically, the scoring prompts provide the judge's large language model with four evaluation criteria: fluency, naturalness, semantic richness, and logical coherence, and output the fluency score for each criterion. Naturalness semantic richness and logical coherence Four integer scores, ranging from 1 to 5, are used. Fluency evaluates grammatical correctness, smooth expression, and the absence of awkward structure; Naturalness evaluates whether the sentences conform to the spoken language habits of real users in conversations or query scenarios; Semantic Richness evaluates whether the sentences contain specific and non-trivial information and avoid vague expressions; Logical Coherence evaluates whether the sentences are consistent internally and whether there are no contradictory or obviously unreasonable intentions or slot combinations. The overall quality score is calculated as the arithmetic mean of the four dimensions. .when If the quality score is not lower than the preset quality threshold, the statement will be retained; otherwise, it will be deleted. Preferably, the preset quality threshold is 3.0 points.

[0027] Step S4: Cross-model consensus verification extracts high-confidence samples.

[0028] This step is crucial for achieving "no annotation" while ensuring annotation quality. Preferably, it includes: Step S41: Disabling the initial label constraints from step S2, and filtering the qualified query statements from step S3. The data is directly fed into the first and second language models, which are in a zero-shot state (at this point, they act as parsers). Step S42: Obtain the independent parsing results of the two models. The parsing result of the first language model is denoted as... The parsing result of the second largest language model is denoted as Step S43: Perform rigorous cross-model consensus. The system compares the outputs of the two models, and only if the following absolute consistency condition is met: The intent judgments are completely consistent: Furthermore, the slot names and their corresponding character spans in the text are completely identical: If the two models reach a consensus, it proves that the analysis is extremely reliable. The system will then process this statement. The corresponding analysis results are stored in the training set as "high confidence samples"; otherwise, any inconsistencies are marked as "disagreement samples".

[0029] Step S5: Introduce the judge's big language model to arbitrate and resolve disputes among the samples.

[0030] Because multi-intent statements are complex, discrepancies are inevitable between the two models. Directly discarding discrepancies would result in a homogeneous data distribution. Step S51: For discrepancies, this embodiment retrieves their original query statements. The initial canonical tuple of step S1 and the first analysis result that caused the conflict. Second analysis result As contextual prompts, these are uniformly packaged and input into the judge's large language model. Step S52: Based on its powerful reading comprehension and error correction capabilities, the judge's large language model compares the erroneous or incomplete results given by the two models, and combines this with the initially set slot constraints to perform comprehensive reasoning, outputting the final corrected unique optimal parsing label. Specifically, the initially set slot constraints include at least the following conditions: 1. Satisfying the allowed intent tag set; 2. Satisfying the allowed slot tag set; 3. The sampled slot value tag pairs and slot values ​​in the canonical tuple must be exact continuous substrings in the original natural language query statement; 4. Intents or slots outside the canonical set must not be introduced; 5. Slot values ​​not explicitly appearing in the original sentence must not be inferred, etc.

[0031] The comprehensive reasoning process in step S52 may include the following sub-steps: S521, Legality verification: Check whether the intent label and slot label in the first and second parsing results both belong to the preset legal set; S522, Text alignment verification: Check whether each slot value is an exact substring in the original query statement and record its character boundaries; S523, Candidate consistency comparison: Calculate the matching between the candidate parsing and the original query statement, the canonical tuple, and the legal label definition respectively, and prioritize retaining the intent and slot that are correctly identified by at least one model and satisfy the text alignment constraint; S524, Conflict resolution: When two candidate results conflict on the intent category, slot label, or slot value boundary, select the result with finer granularity and most consistent with the direct expression of the original sentence based on the semantics of the original sentence, the legal label definition, the slot description, and the initial constraints given in the canonical tuple. The initial constraints given in the canonical tuple refer to the canonical information already determined in steps S1 to S2 for the divergent sample, including: the sampled intent set I, the sampled slot label set S, and the slot value-label pairs determined based on the slot library and used to generate the statement. These initial constraints serve only as reference constraints for conflict resolution in the arbitration model, used to determine whether candidate parsing deviates from the original target when the sample was generated. If the constraints are inconsistent with the explicit expression of the original query statement, the explicit semantics and legal label definitions in the original query statement shall prevail. S525, Reconstructing the Parsing: If both candidate results contain illegal labels, incorrect slot values, or omissions, then without adding information not present in the original sentence, legal intents and slot value-label pairs are re-extracted based on the original sentence. S526, Formatted Output: Output a unique set of intents and slot value-label pairs according to a preset format, as the optimal parsing label.

[0032] Step S53: Convert the original statement With optimal parsing labels The samples are then combined to form "arbitration samples". Subsequently, all arbitration samples are merged with the high-confidence samples obtained in step S4 to completely complete the construction of the unlabeled high-quality synthetic dataset.

[0033] Step S6: Perform supervised fine-tuning (SFT) on the large language model to achieve collaborative self-distillation.

[0034] Step S61: Format the high-quality synthetic dataset into "Instruction-Response pairs". For example, the instruction is: "Please parse multiple intents and slots of the following sentence: [Query statement T]", and the response is the target structured label. Step S62: Use a parameter-efficient fine-tuning algorithm (such as Low-Rank Adaptation, LoRA) to input the training set into the first and / or second large language models. The LoRA algorithm significantly reduces computational and memory overhead by freezing most of the weights of the pre-trained model and injecting only trainable low-rank matrices into the Transformer layer. Step S63: During training, use an autoregressive mode to calculate the cross-entropy loss function between the model's predicted output and the high-quality synthetic labels, and backpropagate to update the gradient weights of the LoRA module. After multiple rounds of iterative training, the originally divergent and illusion-prone "text generation ability" of the large language model is successfully transformed into a strictly formatted and precisely aligned "spoken semantic parsing ability," achieving a performance reversal and self-distillation of the smaller model. The output model at this point is a target multi-intent semantic parsing model that can be deployed to the terminal.

[0035] After the target multi-intent semantic parsing model is deployed, semantic parsing can be performed on the natural language data to be parsed (such as the user's voice input) and the parsing results can be obtained.

[0036] Example 2 Based on the cooperative self-distillation method described in Example 1, Example 2 of the present invention provides a corresponding logical system capable of executing the method of this solution as given in Example 1. This system can be deployed on a cloud server or a local high-performance computing cluster. Please refer to... Figure 3 The system specifically includes the following core modules and internal sub-units: 1. Sampling and Constraint Module (Data Engine) This module is primarily responsible for the initialization of domain knowledge and the generation of constraints, specifically including: Ontology Database: Used for persistent storage of intent sets and entity slots within the target application domain; Multi-Value Sampler (MVS Sampler): It has a built-in random number generator and probability control unit, which is used to randomly extract multiple intents in each generation task and allow the same slot label to map multiple specific entity words from the ontology database, and finally package and output canonical tuples.

[0037] 2. Reverse Progressive Generation Module (Generate Console) This module is the core component for interfacing with the underlying Large Language Model (LLM) to achieve data synthesis, and specifically includes: Skeleton building unit: Injects the canonical tuple into the preset Prompt template, calls the inference interface of the first / second large language model generation, and obtains the coarse-grained semantic draft (Overview) and the determined slot key-value pairs; Statement synthesis unit: The output of the above skeleton building unit is used as a hard constraint to trigger the generation of the large language model again, forcing it to splice and generate user query statements that are grammatically correct and fluent in context without creating entity illusions.

[0038] 3. Feature Filtering Module (Quality Funnel) This module is responsible for rigorous data cleaning of massive synthetic corpora, specifically including: High-dimensional vector extraction and comparison unit: It has a built-in lightweight text encoder (Sentence-BERT) that converts newly synthesized sentences into feature vectors. It also includes a matrix multiplication accelerator to calculate the extreme value of the cosine similarity between the vector and vectors in the historical sample pool. When the maximum similarity exceeds a preset threshold, a discard mechanism is triggered. Multi-dimensional scoring call unit: Connects to the judge's large language model API with a larger number of parameters, constructs an evaluation matrix containing four dimensions: "fluency, naturalness, semantic richness, and logical coherence", and calculates the mean score for threshold truncation and filtering.

[0039] 4. Cross-analysis and arbitration module (conflict resolution center) This module is used to achieve high-quality label alignment without human intervention, and specifically includes: Zero-shot parser dispatcher: Hides all hint constraints and distributes the filtered clean sentences in parallel to the first and second language models for zero-shot parsing; Consensus Comparator: Performs strict hash comparison or string exact matching to determine whether the intent labels and slot boundaries output by the two models are absolutely consistent. and If they match, then route them to the "high-confidence sample library"; The arbitration unit is activated when the consensus comparator returns "no". It extracts the conflict results and context of the two models, assembles them into arbitration prompts, and submits them to the large arbitration model for logical reasoning and error correction. It then outputs a unique arbitration label. And routed to the "arbitration sample library".

[0040] 5. Self-distillation fine-tuning module (model training framework) This module is used to complete the "knowledge internalization" of the basic model, specifically including: Data formatting unit: merges the high-confidence sample library and the arbitration sample library, and transforms them into the Instruction-Response standard format required for fine-tuning of the large language model; Parameter Efficient Fine-Tuning (PEFT) Unit: Loads the network weights of the basic large language model, freezes most of the fully connected layer parameters, and only injects a low-rank matrix (LoRA adapter) in the side path of the attention module of the Transformer architecture. Gradient update unit: Using optimizers such as AdamW, the cross-entropy loss is calculated for backpropagation to update the weights of the LoRA adapter. Finally, the weights are merged with the original model weights to derive a target multi-intent speech understanding model with high-precision speech parsing capabilities.

[0041] Example 3 To further illustrate the specific implementation process of the multi-value sampling (MVS) mechanism proposed in step S2 of embodiment 1 of this solution, this embodiment takes the intelligent voice assistant scenario as an example.

[0042] In existing technologies, most data synthesis methods based on large language models typically employ a single-value sampling strategy, meaning that only one entity value is randomly extracted for each slot label. For example, for the slot label "Artist," only the singer's name is extracted; for the slot label "City," only the city's name is extracted. While this method is simple to implement, the structural complexity of the generated corpus is low, making it difficult to simulate the situation where real users mention multiple entity objects simultaneously during actual interactions.

[0043] For example, in a music playback scenario, users might make complex requests like, "Please play songs in AAA and BBB formats." In a navigation scenario, a user might say, "Please plan my route from Beijing to Shanghai and then to Hangzhou." In a smart home scenario, a user might say, "Turn off the lights in the living room and bedroom." The above statements all involve situations where the same slot label corresponds to multiple slot values, and traditional single-value sampling mechanisms cannot effectively cover such complex scenarios. To address this issue, this solution proposes a multi-value sampling mechanism. First, a domain ontology database is constructed. This database contains an intent set I and a slot set S for the target domain.

[0044] Taking the music field as an example: the intent set includes: Play Music; Pause Music; Switch Songs; Query Artist Information, etc.

[0045] The slot set includes: Artist; Song; Album; Language, etc.

[0046] Meanwhile, an entity slot library (Slot Bank) is constructed. For example: the Artist slot corresponds to the entity set: {AAA, BBB, CCC, DDD, EEE}, where the characters in the set represent the names of multiple singers; the Song slot corresponds to the entity set: {Qing XX, XXX, XX, XXXX}, where the set represents song names; the Album slot corresponds to the entity set: {November XXX, Ye XX, Fan XX}, where the set represents album names.

[0047] When generating samples, the system first randomly samples an intent. For example, the sampling result is: PlayMusic. Subsequently, it randomly samples a slot, such as: Artist. The traditional solution only randomly selects one entity value. For example: Artist = AAA. However, this solution allows sampling multiple entity values for the same slot label. For example: Artist = {AAA, BBB}.

[0048] Furthermore, the sampling quantity k can be set to satisfy: 1 ≤ k ≤ N. Where N represents the total number of entities in the corresponding slot library. In a preferred embodiment, the value range of k is from 1 to 4. Therefore, the system can generate the following slot key-value pairs: Artist1 = AAA; Artist2 = BBB.

[0049] Subsequently, it enters the reverse progressive generation stage. The system first generates a semantic draft: "The user hopes to play the songs of AAA and BBB." Then, based on the semantic draft and the determined slot values, it generates a natural language query statement: "Please play the classic songs of AAA and BBB." Furthermore, in the navigation field, more complex task scenarios can also be constructed through multi-value sampling. For example: Intent = Navigation; Slot = City; sampling result: City = {Beijing, Shanghai, Hangzhou}. Generate a semantic draft: "The user hopes to plan a travel route between Beijing, Shanghai and Hangzhou." Generate a natural language query statement: "Help me plan a route from Beijing to Shanghai and then to Hangzhou." Another example is in the smart home scenario: Intent = ControlDevice; Device = {living room light, bedroom light}. Generate a semantic draft: "The user hopes to control the living room light and the bedroom light simultaneously." Generate the final statement: "Turn off the lights in the living room and bedroom." This solution introduces a multi-value sampling mechanism, enabling the generated corpus to cover complex expression patterns in real user interactions, and greatly improving the diversity and structural complexity of the generated samples.

[0050] Compared with single-value sampling, multi-value sampling can generate more complex training samples containing multiple entities, multiple slots, and multiple intent couplings, thereby effectively improving the generalization ability and robustness of the target multi-intent spoken language understanding model obtained from subsequent training for complex scenarios.

[0051] Experiments show that, under the same generation scale, the semantic coverage of the generated corpus is significantly improved and the proportion of duplicate samples is significantly reduced after adopting the multi-value sampling mechanism of the present invention. At the same time, it can construct a training dataset that is more in line with the expression habits of real users, providing a high-quality data foundation for subsequent collaborative self-distillation training.

[0052] Example 4 To further illustrate the specific implementation process of the Reverse Progressive Generation mechanism proposed in step S2 of embodiment 1 of this solution, this embodiment will provide a detailed explanation in conjunction with the intelligent voice assistant scenario.

[0053] In existing technologies, large language models typically employ a forward generation approach to construct training samples, meaning that task descriptions are directly input into the large language model to generate natural language sentences. However, due to the lack of explicit constraints in the generation process, large language models are prone to issues such as entity omissions, slot missing, semantic drift, and intent deviation, leading to inconsistencies between the generated samples and the expected annotation results.

[0054] For example, if the system's preset intent is: PlayMusic; QueryWeather, and the corresponding slot constraints are: Artist=AAA; City=Beijing; Date=Tomorrow, using the traditional forward generation method, the large language model might generate the following statement: "Play songs by AAA." This statement only retains the intent to play music, omitting the intent to query the weather.

[0055] For example, generating the statement "Play AAA's song and check Shanghai's weather," while containing two intents, results in a city entity shift from Beijing to Shanghai. Such situations can lead to errors in subsequent automatic annotation, reducing the quality of training data. To address these issues, this invention proposes a reverse progressive skeleton generation mechanism. This mechanism does not directly generate the final natural language query statement, but rather completes data synthesis according to a layer-by-layer constraint approach: "semantic draft construction → slot mapping generation → natural language expression generation." Specifically, it includes the following steps.

[0056] Phase 1: Constructing canonical tuples.

[0057] First, obtain the canonical tuples according to the multi-value sampling mechanism in Example 3. For example: Intent={PlayMusic,QueryWeather}; Slot={Artist=AAA,City=Beijing,Date=tomorrow} The aforementioned canonical tuples explicitly stipulate that the final generated statement must contain two intents and three slot values.

[0058] Phase Two: Generating a Semantic Draft.

[0059] The system inputs canonical tuples into the generation model and requires the model to generate a semantic draft describing the user's needs based on the canonical tuples, instead of directly generating the final natural language query. Unlike traditional template filling methods, the semantic draft generated by this invention already contains the corresponding slot value information in the canonical tuples, retaining only the abstract description at the natural language expression level, thereby ensuring semantic and entity consistency in the subsequent generation process.

[0060] For example, consider the following canonical tuple: Intent={PlayMusic, QueryWeather}; Slot={Artist=AAA, City=Beijing, Date=Tomorrow}.

[0061] The semantic draft generated by the system can be expressed as: "The user wants to play a song by AAA and check the weather in Beijing tomorrow." At this point, the semantic draft has fully contained the target intent and the corresponding slot value information, but it has not yet formed a natural language query statement that conforms to the expression habits of real users, so it is still an intermediate semantic representation.

[0062] Furthermore, to ensure consistency between the semantic draft and the canonical tuples, the system performs a constraint consistency check on the generated result. Specifically, it verifies whether the semantic draft completely contains all intent information and all slot value information corresponding to the canonical tuples. If any issues are found in the semantic draft, such as missing slots, entity replacements, added entities, missing intents, or semantic offsets, the current generated result is determined to not meet the constraint requirements, and the semantic draft generation process is re-executed.

[0063] For example, when the canonical tuple contains Artist=AAA, City=Beijing, and Date=tomorrow, and the generated result is "The user wants to play AAA's song and query the weather in Shanghai tomorrow", the semantic draft is judged as an invalid sample and discarded because the city entity is incorrectly replaced by "Shanghai" instead of "Beijing".

[0064] For example, when the generated result is "The user wants to play AAA songs", it is also judged as an invalid sample because the weather query intent is omitted.

[0065] Through the above constraint mechanism, it can be ensured that the semantic drafts entering the subsequent stages are strictly consistent with the original canonical tuples, thus providing a reliable foundation for the subsequent generation of natural language expressions.

[0066] Phase 3: Slot key-value pair construction.

[0067] After obtaining the semantic draft, the system extracts the corresponding slot key-value pair information from the original canonical tuples to construct a structured constraint representation. The structured constraint representation includes the slot name and the corresponding slot value.

[0068] For example, for the semantic draft above, the corresponding constructed slot key-value pairs are: Artist=AAA; City = Beijing; Date = Tomorrow.

[0069] The slot key-value pairs serve as structured supervision information and are input into the subsequent generative model along with the semantic draft. The semantic draft provides complete task semantic constraints, while the slot key-value pairs provide precise entity constraints; together, they constitute a dual constraint mechanism.

[0070] Furthermore, in multi-intent scenarios, it is also possible to construct more complex slot key-value pair structures. For example, for the following canonical tuple: Intent={SetAlarm, SendMessage, QueryWeather}; Slot={Time=Tomorrow morning at 8:00, Contact=Zhang San, City=Beijing}.

[0071] The generated semantic draft is: "The user wants to set an alarm for 8:00 AM tomorrow, send a reminder message to Zhang San, and check the weather in Beijing." The corresponding key-value pairs for the slots are: Time = Tomorrow morning at 8:00 AM; Contact = Zhang San; City = Beijing.

[0072] By simultaneously retaining both semantic drafts and slot key-value pairs as intermediate representations, the system can utilize both semantic and entity constraints during subsequent natural language expression generation, effectively avoiding issues such as entity omission, slot drift, entity replacement, and semantic shift.

[0073] Compared with existing direct generation methods, this scheme realizes a natural language generation process under dual constraints by constructing a semantic draft containing specific slot values ​​and corresponding structured slot key-value pairs. This can significantly improve the consistency between generated samples and canonical tuples, improve the accuracy and reliability of automatically labeled data, and provide a high-quality data foundation for subsequent cross-consensus verification and collaborative self-distillation training.

[0074] Example 5 To further improve the accuracy and reliability of automatically constructed training data, this scheme introduces a cross-consensus verification and arbitration mechanism after obtaining the natural language query statement. Multiple semantic parsing models independently parse the same sample, and consistency judgment and arbitration decisions are used to select high-quality training samples. This embodiment describes the preferred execution method of this cross-consensus verification and arbitration approach.

[0075] In existing technologies, when using a single large language model to automatically annotate generated sentences, errors in the automatic annotation results are easily caused by problems such as illusions, inference biases, and insufficient domain knowledge inherent in the model itself. For example, for the same user query, calling the same model at different times may produce different parsing results, thus affecting the quality of the training data.

[0076] To address the aforementioned issues, this solution employs at least two independent semantic parsing models to perform the parsing task separately.

[0077] For example, consider the following natural language query: "Please play AAA's song and check the weather forecast for Beijing tomorrow." The output of the first semantic parsing model is: Intent={PlayMusic, QueryWeather}; Slot={Artist=AAA, City=Beijing, Date=Tomorrow}.

[0078] The output of the second semantic parsing model is: Intent={PlayMusic, QueryWeather}; Slot={Artist=AAA, City=Beijing, Date=Tomorrow}.

[0079] The system performs a consistency comparison on the two parsing results.

[0080] Since the intent sets output by the two models are completely identical, and the slot sets and corresponding slot values ​​are also completely identical, the system determines that the sample passes the consensus verification and marks it as a high-confidence sample.

[0081] Subsequently, the high-confidence sample was directly added to the high-quality training dataset.

[0082] Furthermore, for more complex multi-intent scenarios, the system performs the same verification process.

[0083] For example, for natural language query statements: "Please set my alarm for 8 a.m. tomorrow and send a reminder message to Zhang San, and also check the weather in Beijing." Output of the first semantic parsing model: Intent={SetAlarm, SendMessage, QueryWeather}; Slot={Time=Tomorrow morning at 8:00, Contact=Zhang San, City=Beijing}.

[0084] Output of the second semantic parsing model: Intent={SetAlarm, SendMessage, QueryWeather}; Slot={Time=Tomorrow morning at 8:00, Contact=Zhang San, City=Beijing}.

[0085] Since the analysis results are completely consistent, this sample is also marked as a high-confidence sample.

[0086] However, in practical applications, different models may have different interpretations of complex statements.

[0087] For example, for the following query statement: "Please set the air conditioner to 24 degrees Celsius and check the weather forecast for Shanghai tomorrow." Output of the first semantic parsing model: Intent={ControlAirConditioner, QueryWeather}; Slot={Temperature=24,City=Shanghai,Date=tomorrow}.

[0088] Output of the second semantic parsing model: Intent={ControlDevice, QueryWeather}; Slot={Temperature=24,City=Shanghai,Date=tomorrow}.

[0089] Although the two models identified the same slot information, they differed in their classification results for air conditioning control intent. Therefore, the system determined that the sample failed the consensus verification.

[0090] For samples that fail consensus verification, an arbitration model is introduced to execute arbitration decisions.

[0091] Specifically, the referee model receives the following input information: Raw natural language query statement; Original canonical tuple; Output of the first semantic parsing model; The output of the second semantic parsing model.

[0092] Subsequently, the judge model performs a comprehensive analysis by combining the semantic information of the original statement, the constraint information of the canonical tuples, and the parsing results of multiple models.

[0093] Specifically, the comprehensive analysis process includes: first, performing a legality check on candidate parsings to remove labels that do not belong to the predefined intent set or slot set; second, performing a slot value boundary check, requiring that the slot value must be an exact substring in the original query statement and must not be replaced by synonyms, normalized rewrites, or fabricated; third, comparing each candidate parsing with the canonical tuple constraints, intent definitions, and slot definitions item by item to determine whether each candidate has missing intents, over-identified intents, incorrect slot labels, incorrect slot values, or incomplete boundaries; finally, under the premise of satisfying legal labels and text alignment, selecting the candidate result that is most consistent with the original semantics, or merging the correct intents and slot fragments from multiple candidate results to generate a new final parsing result.

[0094] For the above samples, the final output of the referee model is: Intent={ControlAirConditioner, QueryWeather}; Slot={Temperature=24,City=Shanghai,Date=tomorrow}.

[0095] Since the judge model considers "air conditioning control" to belong to a more granular intent classification, the result of the first semantic parsing model is selected as the final parsing result.

[0096] After the arbitration is completed, the sample is added to the arbitration sample database.

[0097] Furthermore, analytical discrepancies may also arise in industrial control scenarios.

[0098] For example, for a query statement: "Start the second circulation pump and check the current temperature of reactor A and the alarm records of the last 24 hours." Output of the first semantic parsing model: Intent={ControlPump, QueryTemperature, QueryAlarm}.

[0099] Output of the second semantic parsing model: Intent={StartDevice, QueryTemperature, StatisticsAlarm}.

[0100] Because of the difference in intent labels, the system submits the sample to the referee model.

[0101] Given that the current sample belongs to the industrial control field, the referee model analyzes the original query statement, canonical tuple information, legal intent label definitions, legal slot label definitions, and two candidate parsing results, and outputs the final result: Intent={ControlPump, QueryTemperature, QueryAlarm}.

[0102] The corresponding samples will be added to the arbitration sample library.

[0103] Specifically, the analysis and comparison process includes: First, the adjudicator model determines that the current statement should be understood according to industrial control semantics based on the target domain description given in the input prompt; then, it compares the intent tags, slot tags, and slot values ​​in the two candidate parsing results with the original query statement, canonical tuples, and legal tag definitions, respectively. If the candidate result contains a more generalized intent tag such as "StartDevice," while the original query statement explicitly contains equipment control expressions such as "Start No. 2 circulating pump," and the legal tag definition contains "ControlPump," which is a better match for this expression, then the fine-grained intent tag that is more consistent with the explicit semantics of the original sentence is selected first. If the candidate result parses "recent 24-hour alarm records" as a statistical intent, while the expressions "query" and "alarm records" in the original sentence more directly correspond to the query semantics of alarm records, then "QueryAlarm" is selected as the corresponding intent. After the above comparison, the adjudicator model retains the parsing results that are consistent with the original query statement, canonical tuples, and legal tag definitions without introducing information not present in the original sentence or using illegal tags, and outputs the final result.

[0104] In a preferred embodiment, the system employs a fully consistent matching strategy to perform consensus verification. That is, a sample is only considered a high-confidence sample if all intent labels, all slot labels, and all slot values ​​output by multiple parsing models are consistent.

[0105] In other implementations, a partial consistency verification strategy can also be adopted. For example, a comprehensive consistency score can be calculated based on the intent matching rate, slot matching rate, and slot value matching rate. When the comprehensive consistency score is higher than a preset threshold, the corresponding sample is identified as a high-confidence sample.

[0106] By introducing a cross-consensus verification mechanism, this invention can automatically filter high-reliability samples using the consensus results among multiple models; by introducing an arbitration mechanism for adjudicating models, this invention can further process complex samples with analytical disagreements, thereby significantly improving the accuracy and consistency of automatic labeling results.

[0107] Ultimately, the samples in the high-confidence sample library and the arbitration sample library together constitute a high-quality training dataset, providing reliable supervision signals for subsequent collaborative self-distillation training, thereby improving the recognition accuracy and generalization ability of the target multi-intent semantic parsing model.

[0108] Example 6 In order to enable the implementation of the present invention to be carried out on actual physical hardware, this embodiment provides an electronic device and a computer-readable storage medium.

[0109] 1. Electronic devices Please see Figure 4 This embodiment provides an electronic device, which can be an AI server cluster or high-performance computing node used for training large models, or a terminal device such as a smart vehicle infotainment system or smart speaker that has deployed a lightweight analytical model. Specifically, the electronic device includes: Processor: such as a central processing unit (CPU), preferably also including a graphics processing unit (GPU) or tensor processor (TPU / NPU) specifically for large-scale tensor computation and neural network inference / fine-tuning. Memory: This includes high-speed random access memory (RAM) and non-volatile memory (ROM, such as solid-state drives SSDs) used to persistently store the ontology database, the generated corpus, and the fine-tuned model files. Network Interface: A network interface is used for data communication between electronic devices and external servers, databases, or other computing devices. System bus (Bus): Used to enable internal data communication and control instruction transmission between the aforementioned processor, memory, and communication interface.

[0110] The memory stores a computer program (or instruction set) that can run on the processor. When the processor executes the computer program, it can fully implement all the steps in the unlabeled multi-intent parsing method based on cooperative self-distillation in Embodiment 1 above (including calculation processes such as data sampling, reverse generation, filtering and scoring, cross arbitration, and LoRA self-distillation fine-tuning).

[0111] 2. Computer-readable storage medium This embodiment also provides a non-volatile computer-readable storage medium (such as a USB flash drive, portable hard drive, optical disc, server cloud drive, etc.). Computer-executable instructions / program code are pre-written or stored on this storage medium.

[0112] When the storage medium is connected to any electronic device with computing capabilities, the processor in the device can read and execute the instructions in the storage medium, thereby enabling the electronic device to perform the unlabeled multi-intent semantic parsing method as described in Example 1.

[0113] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0114] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention 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 the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. An unlabeled multi-intent semantic parsing method, characterized in that, Includes the following steps: S1. Obtain the intent set and slot set corresponding to the target domain, and generate a canonical tuple containing multiple intents and multiple slots according to the preset sampling rules; S2. Based on the canonical tuples and the preset slot library, perform reverse progressive skeleton generation to generate the corresponding semantic draft, slot value tag pairs and natural language query statements; S3. The natural language query statement is represented by a vector, and sample deduplication is performed according to a preset semantic similarity threshold. Quality filtering is performed according to the quality score. S4. Use at least two semantic parsing models to independently parse the natural language query statement to obtain the corresponding intent prediction result and slot prediction result; S5. Perform cross-consensus verification based on the intent prediction result and slot prediction result. When the parsing results of multiple semantic parsing models are consistent, they are determined as high-confidence samples. When the parsing results are inconsistent, the corresponding samples are input into the arbitration model for conflict resolution to obtain the final parsing result. S6. Construct a training dataset based on the high-confidence samples and arbitration samples, and use the training dataset to perform supervised fine-tuning of the target semantic parsing model to obtain the target multi-intent semantic parsing model. Use the target multi-intent semantic parsing model to perform semantic parsing on the target language data.

2. The method of claim 1, wherein, The canonical tuple is generated by randomly sampling at least one intent from the intent set, randomly sampling at least one slot from the slot set, and sampling multiple different slot values ​​for the same slot label, thereby constructing a canonical tuple containing multi-value slots.

3. The method of claim 1, wherein, The reverse progressive skeleton generation includes: generating a semantic draft containing all intent and slot constraint information based on canonical tuples, and generating a natural language query statement based on the semantic draft and slot value label pairs, so that the generated natural language query statement simultaneously satisfies the semantic draft constraints and the slot value label pair constraints.

4. The method according to claim 1, characterized in that, The sample deduplication process includes: encoding the natural language query statement using a text encoding model to obtain a semantic vector; calculating the cosine similarity between the semantic vector and the semantic vector of historical samples; and deleting the corresponding sample when the maximum cosine similarity is greater than a preset threshold.

5. The method of claim 1, wherein, The quality score includes one or more of the following: language fluency score, semantic integrity score, logical consistency score, and expression naturalness score. A comprehensive quality score is calculated based on the scores of each dimension, and samples with a comprehensive quality score higher than a preset threshold are retained.

6. The method of claim 1, wherein, The cross-consensus verification includes: the first semantic parsing model outputs a first intent set and a first slot set, the second semantic parsing model outputs a second intent set and a second slot set, and when the first intent set is consistent with the second intent set and the first slot set is consistent with the second slot set, the corresponding sample is marked as a high-confidence sample.

7. The method of claim 1, wherein, The arbitration model receives the original natural language query statement, canonical tuples, the output of the first semantic parsing model, and the output of the second semantic parsing model, and generates the final parsing result based on the above input information.

8. The method of claim 1, wherein, The supervised fine-tuning adopts a parameter-efficient fine-tuning method, which is the low-rank adaptive LoRA method. The model parameters are updated by calculating the loss function between the model prediction results and the labeled results of the training dataset, thereby obtaining a target multi-intent semantic parsing model.

9. An unlabeled multi-intent semantic parsing system, comprising: The system is used to perform the method as described in any one of claims 1-8, and the system includes: a sampling and constraint module, a reverse progressive generation module, a feature filtering module, a cross-analysis and arbitration module, and a self-distillation fine-tuning module; The sampling and constraint module is used to generate canonical tuples, the reverse progressive generation module is used to generate natural language query statements based on the canonical tuples, the feature filtering module is used to perform sample deduplication and quality filtering, the cross-parsing and arbitration module is used to perform consensus verification and conflict resolution, and the self-distillation fine-tuning module is used to construct the training dataset and complete the supervised fine-tuning of the model.

10. An unlabeled multi-intent semantic parsing apparatus, comprising: The system includes a processor, a memory, a communication interface, and a system bus, wherein the memory stores a computer program, and the processor invokes the computer program via the system bus to execute the method according to any one of claims 1 to 8.

Images