A Deep Learning-Based Method and System for Software Non-Functional Requirements Analysis

Abstract

This invention provides a method and system for analyzing non-functional requirements of software based on deep learning, including the following steps: S1, acquisition and preprocessing; S2, structured extraction; S3, intelligent recommendation; S4, user feedback; S5, optimization judgment. This invention does not rely on manual intervention, can parse abstract requirements and recommend solutions based on project scenarios, and can also self-iterate and evolve, with high parsing efficiency and wide applicability.

Description

Technical Field

[0001] This invention relates to the field of software development technology, and more specifically to a method and system for analyzing non-functional requirements of software based on deep learning. Background Technology

[0002] In modern large-scale software development practices, the analysis and management of non-functional requirements are crucial for ensuring the quality, stability, and user experience of the final product. However, in actual software development, non-functional requirements, due to their highly subjective and hidden nature, are often overlooked or delayed by developers, potentially becoming a source of failure for small projects.

[0003] In software requirements engineering practice, the identification and analysis of non-functional requirements mainly rely on manual operations by requirements analysis experts. This analysis model depends on experienced requirements analysts or system architects who manually read large amounts of unstructured text such as requirements documents to identify and understand non-functional requirements. This model is entirely dependent on manual labor, which is not only time-consuming and labor-intensive, but also highly correlated with the quality of the analysis structure and highly susceptible to omissions or misunderstandings of key requirements due to subjective judgment or negligence. While using automated tools based on natural language processing technology can be effective, knowledge storage and retrieval still require manual keyword searches, and there are significant shortcomings in handling complex semantic relationships and contextual information, making it difficult to fully capture the deep semantic features in the requirements text.

[0004] For example, patent document with patent application number 202411355779.9 and publication date of December 31, 2024 discloses an intelligent method and system for structuring requirements. Based on natural language descriptions of business requirements, it generates structured requirement documents that can be used for subsequent software development. For simple requirements of a single module, a single sentence input is sufficient; for complex requirements of multiple modules, a business modeling intelligent agent is invoked to perform modeling understanding, transforming the natural language requirements into a set of business concepts, which are then further decomposed into specific structured requirements by the requirement structuring intelligent agent.

[0005] The above literature uses Large Language Model (LLM) and Retrieval Enhancement Generation (RAG) technologies. Through a process of requirement input, complexity judgment, concept set generation, and structured document output, it focuses on the decomposition and standardized presentation of requirements. The core technology is the semantic parsing and structured transformation of natural language. It requires a piece of natural language requirements, but it cannot extract and determine the recommended solution based on an original requirement document. The efficiency is low in the early stage of software development, and it cannot automatically adjust the recommended solution based on subsequent feedback after requirement analysis. However, when associating, it still requires human understanding of the context before operation, which still consumes a lot of development time. Summary of the Invention

[0006] This invention provides a method and system for analyzing non-functional requirements of software based on deep learning. By performing multi-dimensional and structured analysis of natural language, it utilizes an intelligent recommendation engine to accurately evaluate requirement descriptions and constructs an evolvable, closed-loop recommendation system.

[0007] To achieve the above objectives, The present invention provides, in one aspect, a method for analyzing non-functional requirements of software based on deep learning, comprising the following steps: S1. Receive one or more original requirement documents containing natural language, preprocess them, and transform the original requirement documents into sentence datasets. S2. Perform semantic parsing on the sentence dataset to form structured NFR objects; S3. For the structured NFR object that triggers the processing, search and determine the candidate solution corresponding to the structured NFR object. Extract the contextual label from the original requirement document solution and combine it with the current NFR object to construct a feature vector. The feature vector includes the quality of the candidate solution and the maintenance cost. According to the label corresponding to the feature vector in the contextual label of the candidate solution, input it into the dynamic feature weighting network to determine the weight of the feature vector. The feature vector and the weight are weighted to obtain the weighted feature vector. The weighted feature vector is then input into the ranking learning model for training to output the final ranking score and the corresponding recommendation report. S4. Output a recommendation report corresponding to the selected information based on the selected information; S5. Continuously receive feedback information. After the accumulated feedback information reaches a preset value, add the weighted feature vector corresponding to the feedback information to the incremental data of the training pool. Then, through the incremental data of the training pool and the weighted feature vector, train the ranking learning model and update the training output to finally rank the data.

[0008] The above method first transforms the original requirement document into a sentence dataset. Then, it parses the sentence dataset to determine the structured NFR objects corresponding to entities, relations, and hierarchical intents. This allows the original requirement document to be decomposed into sentences, and then each sentence into NFR objects corresponding to entities, relations, and hierarchical intents, providing an accurate foundation for subsequent computational analysis. Candidate solutions are searched for these structured NFR objects, and feature vectors are constructed from these candidates. These feature vectors consider solution quality and maintenance cost. The contextual labels of the candidate solutions are then input into a dynamic feature weighting network to determine the weights corresponding to the feature vectors. This process uses multiple aspects of solution quality and maintenance cost in the feature vectors to determine the final ranking scheme, thus providing a... The system provides recommendation reports tailored to different concerns regarding solution quality and maintenance costs. These reports can be generated from a single original document without requiring users to input keywords. User interactions based on these reports are transformed into feedback signals, allowing the system to continuously receive evaluation information from real-world usage environments. This feedback is used to train and re-rank the recommendation reports, ensuring that user feedback influences subsequent reports and leads to more accurate recommendations. This closed-loop analysis system reduces reliance on manual analysis experience, lowers the cost and time of requirement processing and solution recommendation, and continuously improves the system's analytical capabilities, enabling the collective accumulation and automated transfer of expert tacit knowledge.

[0009] Furthermore, the preprocessing in step S1 includes S11-S14: S11. Based on the original requirements document, extract all text content from the original requirements document; S12. Eliminate structural noise, delete content-level noise, and normalize full-width English characters to half-width lowercase characters to obtain clean text; S13. The clean text is processed through two-stage intelligent sentence segmentation. The two-stage intelligent sentence segmentation includes the collaborative work of a rule engine and a CRF model to identify period segmentation points and split the clean text into two independent sentences to form an initial sentence dataset. S14. The initial sentence dataset is processed through a three-stage lexical analysis to form a sentence dataset. The three-stage lexical analysis includes a first stage, a second stage, and a third stage. In the first stage, the domain dictionary is used to perform the best match on the core terms and verb-object phrases to form domain terms. In the second stage, the domain terms are fused and segmented using a CRF model to complete basic segmentation. After the basic segmentation is completed, the third stage performs syntactic analysis on the basic segmentation structure. If the probability of the syntactic tree is lower than a preset threshold, the abnormal segments are re-segmented.

[0010] The above method removes unwanted original text through text extraction and multi-stage cleaning steps, thereby obtaining clean and unified text. Through two-stage intelligent sentence segmentation, it can match the sentence structure of different documents and improve the accuracy of the sentence segmentation results. Finally, through three-stage lexical analysis, it ensures the accuracy of domain terminology recognition on the one hand, and avoids splitting professional terms on the other hand, thus improving the accuracy of lexical analysis.

[0011] Furthermore, step S2 includes S21-S23: S21, using a ternary joint learning model to perform deep semantic parsing on sentences in each sentence dataset; S22, extracting structured NFR objects of entities, relations and hierarchical intents from sentences by performing three subtasks in parallel: named entity recognition, relation extraction and hierarchical intent classification.

[0012] The above settings extract entities, relationships, and hierarchical intents simultaneously through three subtasks, ensuring that the NFR object contains entities, relationships, and hierarchical intents, which facilitates subsequent processing of the NFR object.

[0013] Furthermore, step S3 also includes: when a contacted NFR object is triggered, a ranking recommendation report is formed through a multi-parallel recall stage and an adaptive fusion ranking stage. The multi-parallel recall stage searches for candidate solutions through three channels: semantic vector, keywords, and collaborative filtering. The adaptive fusion ranking stage uses a dynamic feature weighting network to determine the weights corresponding to the feature vectors based on the item context labels, and determines the weighted feature vectors based on the feature vectors and weights. Finally, the ranking is determined based on the weighted feature vectors and a recommendation report is output.

[0014] The above settings, through the multi-path parallel recall stage, can determine candidate solutions through semantic vectors, keywords and collaborative filtering, and then through the adaptive fusion ranking stage, fuse the contextual labels of multiple solutions to finally determine the recommendation report, making the recommendation report more accurate.

[0015] Furthermore, the adaptive ranking stage of candidate solutions in step S3 includes S31-S33: S31. Extract the document attributes of the candidate solutions and construct the feature vector F by combining them with the current NFR object; S32. Input the contextual labels of the current original requirements document into the dynamic feature weighting network, and output the feature vector W weights through the dynamic feature weighting network; S33, LambdaMART model scoring and ranking: The feature vector F and the feature weight vector W are multiplied element-wise to obtain the context-aware weighted feature vector F′, as shown in formula (1). F′=W*F (1) The weighted feature vector F′ is input into the pre-trained ranking learning model LambdaMART, and the LambdaMART model calculates the final ranking score for each candidate solution. The solutions are then sorted in descending order based on the scores to generate and output a technical solution recommendation report.

[0016] The above method determines the matching information between the solution and the requirements by obtaining the feature vector F of the high-dimensional inherent attributes, and enables the adaptive adjustment of weights for different project scenarios by obtaining the feature weight vector W. The weighted feature vector F′ is obtained by obtaining the feature vector F and the feature weight vector W, which reduces the cost of manually adjusting the weights and enhances the applicability of the system in different project environments.

[0017] Furthermore, step S4 includes: receiving user selection information, determining the selection information of the recommendation report corresponding to the final ranking, and displaying the corresponding recommendation report according to the selection information.

[0018] The above settings will display a corresponding recommendation report based on the user's selections.

[0019] Furthermore, step S5 includes S51-S53: S51. Obtain user feedback information from the log message queue, locate the feature vector corresponding to the feedback information, and update the current reputation of the feature vector using an exponential moving average algorithm with time decay, as shown in formula (2). Current credit rating = (Previous period credit rating × decay factor δ) + (1 - δ) × (weight ω × feedback information) (2); S52, When the absolute value reaches the preset trigger threshold, training samples are generated. The training samples include positive enhancement samples and negative suppression samples. S53. Automatically start the machine learning operation and maintenance pipeline based on Kubeflow according to the preset time period, and fine-tune the learning model LambdaMART based on the training samples.

[0020] The above method can obtain the current reputation score through the previous period's reputation score, the decay factor δ, the scenario weight ω, and the feedback signal value. The calculation is convenient. At the same time, the decay factor can enhance the ability to adjust according to the project context. By generating targeted training samples, it avoids processing redundant data. Finally, through fine-tuning training, it improves the model's adaptability to dynamic changes in projects.

[0021] Another aspect of the technical solution provided by the present invention is: a software non-functional requirements analysis system based on deep learning, including a preprocessing module, an extraction module, an NFR database, a technical solution knowledge base, a recommendation engine, an output module, a feedback module, and an optimization module; The preprocessing module is used to receive one or more original requirement documents containing natural language and preprocess them to transform the original requirement documents into sentence datasets. The extraction module is used to perform semantic parsing on the sentence dataset to form structured NFR objects; The NFR database is used to receive and store structured NFR objects and to create indexes. The technical solution knowledge base is used to define the static attributes, applicability rules, and relationships of technical solutions; The recommendation engine includes a sorting module, which is used to search for and sort candidate solutions. The output module is used to search and determine candidate solutions corresponding to the structured NFR object that triggers the processing, extract contextual labels from the original requirement document solution, and construct feature vectors in combination with the current NFR object. The feature vectors include the quality of the candidate solution and the maintenance cost. Based on the labels corresponding to the feature vectors in the contextual labels of the candidate solutions, the weights corresponding to the feature vectors are input into a dynamic feature weighting network to determine the weights of the feature vectors. The feature vectors and weights are weighted to obtain a weighted feature vector. The weighted feature vectors are then input into a ranking learning model for training to output the final ranking score and a corresponding recommendation report. The feedback module is used to obtain feedback information; The optimization module is used to process the feedback information and iteratively update the output module.

[0022] The above setup first transforms the original requirement document into a sentence dataset. Then, the sentence dataset is parsed to determine the structured NFR objects corresponding to entities, relations, and hierarchical intents. This allows the original requirement document to be decomposed into sentences, and then each sentence into NFR objects corresponding to entities, relations, and hierarchical intents, providing an accurate foundation for subsequent computational parsing. Candidate solutions are searched for these structured NFR objects, and feature vectors are constructed from these candidates. These feature vectors consider solution quality and maintenance cost. The contextual labels of the candidate solutions are then input into a dynamic feature weighting network to determine the weights corresponding to the feature vectors. This process uses multiple aspects of solution quality and maintenance cost in the feature vectors to determine the final ranking scheme, thus providing a... The system provides recommendation reports tailored to different concerns regarding solution quality and maintenance costs. These reports can be generated from a single original document without requiring users to input keywords. User interactions based on these reports are transformed into feedback signals, allowing the system to continuously receive evaluation information from real-world usage environments. This feedback is used to train and re-rank the recommendation reports, ensuring that user feedback influences subsequent reports and leads to more accurate recommendations. This closed-loop analysis system reduces reliance on manual analysis experience, lowers the cost and time of requirement processing and solution recommendation, and continuously improves the system's analytical capabilities, enabling the collective accumulation and automated transfer of expert tacit knowledge.

[0023] Furthermore, the extraction module includes a first decoding head, a second decoding head, and a third decoding head. The first decoding head is used for named entity recognition, extracting atomic information constituting the NFR by labeling BIOES entity tags. The second decoding head is used for relation extraction, identifying the inherent logical relationships between entities by constructing entity pair fusion vectors and inputting them into a multilayer perceptron (MLP) classifier to form structured triples. The third decoding head is used for intent classification, performing a global one-time prediction using the sigmoid activation function to determine the complete hierarchical path of the demand in the predefined intent tree.

[0024] The above settings, by setting up multiple decoding heads, enable end-to-end joint learning within a unified neural network framework, enhancing the model's ability to resolve fuzzy representations. At the same time, by setting up three decoding heads to work in parallel, computational latency is reduced and the model's parsing efficiency is improved.

[0025] Furthermore, the feedback information includes positive feedback information and negative feedback information.

[0026] The above settings, by determining the classification of feedback information, enable the rapid accumulation of feedback signals. Attached Figure Description

[0027] Figure 1 This is a flowchart of the present invention.

[0028] Figure 2 This is a flowchart of the preprocessing steps for this invention.

[0029] Figure 3 The flowchart for the sorting of this invention.

[0030] Figure 4 This is a flowchart illustrating the iterative updates of this invention. Detailed Implementation

[0031] The present invention will now be described in further detail with reference to the accompanying drawings and specific embodiments.

[0032] like Figures 1 to 4 As shown, the deep learning-based method for analyzing non-functional requirements of software includes the following steps: S1. Receive one or more original requirement documents containing natural language and preprocess them to transform the original requirement documents into sentence datasets; the original documents can be in doc or PDF format. S2. Perform semantic parsing on the sentence dataset to form structured NFR objects; S3. For the structured NFR object that triggers the processing, search and determine the candidate solution corresponding to the structured NFR object. Extract the contextual label from the original requirement document solution and combine it with the current NFR object to construct a feature vector. The feature vector includes the quality of the candidate solution and the maintenance cost. According to the label corresponding to the feature vector in the contextual label of the candidate solution, input it into the dynamic feature weighting network to determine the weight of the feature vector. The feature vector and the weight are weighted to obtain the weighted feature vector. The weighted feature vector is then input into the ranking learning model for training to output the final ranking score and the corresponding recommendation report. S4. Output a recommendation report corresponding to the selected information based on the selected information; S5. Continuously receive feedback information. After the accumulated feedback information reaches a preset value, add the weighted feature vector corresponding to the feedback information to the incremental data of the training pool. Then, through the incremental data of the training pool and the weighted feature vector, train the ranking learning model and update the training output to finally rank the data.

[0033] The preprocessing in step S1 includes S11-S14: S11. Based on the original requirements document, extract all text content from the original requirements document; S12. Eliminate structural noise, delete content-level noise, and normalize full-width English characters to half-width lowercase characters to obtain clean text; S13. The clean text is processed through two-stage intelligent sentence segmentation. The two-stage intelligent segmentation includes the collaborative work of rule-based processing and CRF model to identify period segmentation points and split the clean text into two independent sentences to form the initial sentence dataset. S14. The initial sentence dataset is processed through a three-stage lexical analysis to form a sentence dataset. The three-stage lexical analysis includes a first stage, a second stage, and a third stage. In the first stage, the domain dictionary is used to perform the best match on the core terms and verb-object phrases to form domain terms. In the second stage, the domain terms are fused and segmented using a CRF model to complete basic segmentation. After the basic segmentation is completed, the third stage performs syntactic analysis on the basic segmentation structure. If the probability of the syntactic tree is lower than a preset threshold, the abnormal segments are re-segmented.

[0034] In this embodiment, S11 adopts a DOM-based parsing method and combines title meta-information to crop areas irrelevant to the requirements; for PDF and other formatted documents, a dual-channel parallel parsing mode of text layer extraction and OCR image recognition is adopted, and a heuristic scoring algorithm based on vocabulary richness, average word length and garbled character rate is used to filter and output clean text. S12. Multi-stage cleaning: First, remove irrelevant content such as headers, footers, and page numbers using regular expressions to eliminate structural noise; then, remove content-level noise by removing URL links used for deletion, email addresses, and non-required side notes; finally, perform character-level normalization by converting full-width characters to half-width characters and uniformly converting English letters to lowercase. Step S2 includes S21-S23. S21: Perform deep semantic parsing on sentences in each sentence dataset using a ternary joint learning model. S22: Extract structured NFR objects of entities, relations and hierarchical intents from sentences by performing three sub-tasks in parallel: named entity recognition, relation extraction and hierarchical intent classification.

[0035] Step S3 further includes: when a contacted NFR object is triggered, a ranking recommendation report is formed through a multi-parallel recall stage and an adaptive fusion ranking stage. The multi-parallel recall stage searches for candidate solutions through three channels: semantic vector, keywords, and collaborative filtering. The adaptive fusion ranking stage uses a dynamic feature weighting network to determine the weights corresponding to the feature vectors based on the item context labels, and determines the weighted feature vectors based on the feature vectors and weights. Finally, the ranking is determined based on the weighted feature vectors and a recommendation report is output.

[0036] like Figure 3 As shown, the adaptive ranking stage of candidate solutions in step S3 includes S31-S33: S31. Extract the document attributes of the candidate solutions and construct the feature vector F in combination with the current NFR object; In this embodiment, the feature vector F includes numerical features of multiple dimensions such as solution quality, development and maintenance costs, security and consistency risks, and historical performance. S32. Input the contextual labels of the current original requirements document into the dynamic feature weighting network, and output the feature vector weights W through the dynamic feature weighting network; In this embodiment, the feature vector weights W are used to represent the distribution of the degree of importance of each feature when the system makes a decision under the current specific scenario, wherein each feature includes at least cost and risk; S33, LambdaMART model scoring and ranking: The feature vector F and the feature weight vector W are multiplied element-wise to obtain the context-aware weighted feature vector F′, as shown in formula (1). F′=W*F (1) The weighted feature vector F′ is input into the pre-trained ranking learning model LambdaMART, and the LambdaMART model calculates the final ranking score for each candidate solution. The solutions are then sorted in descending order based on the scores to generate and output a technical solution recommendation report.

[0037] Step S4 includes: receiving user selection information, determining the selection information of the recommendation report corresponding to the final ranking, and displaying the corresponding recommendation report according to the selection information.

[0038] like Figure 4 As shown, step S5 includes S51-S53: S51. Obtain user feedback information from the log message queue. Obtain user feedback signals from the log message queue. Feedback signals include "agree (+1)" or "disagree (-1)". Locate the feature vector corresponding to the feedback information. Update the current reputation of the feature vector using an exponential moving average algorithm with time decay, as shown in formula (2). Current reputation score = (previous period reputation score × decay factor δ) + (1 - δ) × (weight ω × feedback signal) (2); In this embodiment, the feedback information includes positive feedback information and negative feedback information. The initial value of the previous period reputation score is preset to 5, the initial value of the decay factor δ is preset to 0.999, the initial value of the feedback information is 0, and when the number of likes in the feedback signal is 10, the value of the feedback signal is 10.

[0039] S52, When the absolute value reaches the preset trigger threshold, training samples are generated. The training samples include positive enhancement samples and negative suppression samples. The preset trigger threshold for positive enhancement samples is +100, and the preset trigger threshold for negative suppression samples is -100. If it is determined to be a positive enhancement sample, the system traces the relevant feedback records that triggered this optimization, constructs a high-quality positive sample pair {weighted feature vector F', target label: 1}, writes it into the "training pool" database table, and resets the reputation of the scheme by subtracting the threshold. If a sample is identified as a negatively suppressed sample, the system constructs a high-quality negative sample pair {weighted feature vector F', target label: 0}, writes it into the "training pool" database table, and resets the reputation score of the scheme after adding a threshold. S53. Automatically start the machine learning operation and maintenance pipeline based on Kubeflow according to the preset time period, and fine-tune the learning model LambdaMART based on the training samples.

[0040] A deep learning-based software non-functional requirements analysis system includes a preprocessing module, an extraction module, an NFR database, a technical solution knowledge base, a recommendation engine, an output module, a feedback module, and an optimization module. The preprocessing module is used to receive one or more original requirement documents containing natural language and preprocess them to transform the original requirement documents into sentence datasets. The extraction module is used to perform semantic parsing on the sentence dataset to form structured NFR objects; The NFR database is used to receive and store structured NFR objects and to create indexes. The technical solution knowledge base is used to define the static attributes, applicability rules, and relationships of technical solutions; The recommendation engine includes a sorting module, which is used to search for and sort candidate solutions. The output module is used to search and determine candidate solutions corresponding to the structured NFR object that triggers the processing, extract contextual labels from the original requirement document solution, and construct feature vectors in combination with the current NFR object. The feature vectors include the quality of the candidate solution and the maintenance cost. Based on the labels corresponding to the feature vectors in the contextual labels of the candidate solutions, the weights corresponding to the feature vectors are input into a dynamic feature weighting network to determine the weights of the feature vectors. The feature vectors and weights are weighted to obtain a weighted feature vector. The weighted feature vectors are then input into a ranking learning model for training to output the final ranking score and a corresponding recommendation report. The feedback module is used to obtain feedback information; The optimization module is used to process the feedback information and iteratively update the output module.

[0041] The extraction module includes a first decoding head, a second decoding head, and a third decoding head. The first decoding head is used for named entity recognition, extracting atomic information that constitutes the NFR by labeling BIOES entity tags. The second decoding head is used for relation extraction, identifying the inherent logical relationships between entities by constructing entity pair fusion vectors and inputting them into a multilayer perceptron (MLP) classifier to form structured triples. The third decoding head is used for intent classification, performing a global one-time prediction using the sigmoid activation function to determine the complete hierarchical path of the demand in the predefined intent tree.

[0042] The following uses the original text read from the PDF document as an example to illustrate steps S11-S14: There is a text message that reads: "Internal Confidential Page 12\n During the Double Eleven period, the system must have high concurrency processing capabilities. The RT of the core interface should be less than 500ms (Note: This is a strict KPI assessment standard) http: / / jira.company.com / req / 123"; The preprocessing module receives the original requirements document containing this text, extracts all text content from the original requirements document, and then begins multi-stage cleaning. First, the system removes structural noise such as "Internal Confidential Page 12," then deletes side notes such as "(Note: This item is a strict KPI assessment standard)" and content-level noise such as http: / / jira.company.com / req / 123. Next, it normalizes the full-width English characters "RT" to lowercase "rt." The final clean text is: "During the Double Eleven period, the system must have high concurrency processing capabilities. The rt of the core interface should be less than 500ms." The obtained clean text is then split into sentence datasets: "The system must have high concurrency processing capabilities during Double Eleven." and "The rt of the core interface should be less than 500ms." Finally, taking "The system must have high concurrency processing capabilities during the Double Eleven period" as an example, we first use a domain dictionary to lock "high concurrency" as a whole to avoid it being mistakenly split into "high" and "concurrency" by the general word segmentation model. Then, the CRF model is used to fuse word segmentation and dependency parsing to finally output the accurate sentence dataset as ["system", "in", "Double Eleven", "during", ",", "must", "have", "high concurrency", "processing", "capability", "."].

[0043] The following example, using the sentence "The rt of the core query interface must be less than 500ms" received by the module, illustrates the workflow of the extraction module: The entities extracted from the received sentence "The rt of the core query interface must be less than 500ms" are as follows: Entity 1 { "text": "Core Query Interface", "type": "SYSTEM_COMPONENT"} (System Component) Entity 2 { "text": "rt", "type": "METRIC"} (Indicator) Entity 3 { "text": "less than", "type": "OPERATOR"} (operator) Entity 4 { "text": "500", "type": "VALUE"} (numerical value) Entity 5 { "text": "ms", "type": "UNIT"} (Unit) For the above entities, the extracted relationships are as follows: Relation 1 { "head": "rt", "type": "hasConstraint" (constraint is), "tail": "less than"} Relation 2 { "head": "less than", "type": "hasValue" (value is ), "tail": "500"} The outputs of the three independent decoding heads are seamlessly mapped and concatenated into a nested JSON object, i.e., a highly structured NFR object. This object can be directly stored in the document database for efficient retrieval by downstream recommendation engines. The specific data structure is as follows: { "source_sentence": "The response time (rt) of the core query interface must be less than 500ms". "intent": { "path": ["performance", "time efficiency", "backend processing"], "confidence": 0.95 }, "entities": [ { "text": "Core Query Interface", "type": "SYSTEM_COMPONENT"}, { "text": "rt", "type": "METRIC"}, { "text": "less than", "type": "OPERATOR"}, { "text": "500", "type": "VALUE"}, { "text": "ms", "type": "UNIT"} ], "relations": [ { "head": "rt", "type": "hasConstraint", "tail": "less than"}, { "head": "less than", "type": "hasValue", "tail": "500"} ] The following uses the requirement sentence "The rt of the core query interface must be less than 500ms" obtained from the above analysis as an example to illustrate steps S31-S33: After multiple parallel recalls, the system initially selected two candidate solutions that could meet the performance requirements: Candidate solution A: "Introducing Guava as an in-process local cache", its feature vector FA shows that: the development cost is extremely low, but there is a high risk of data inconsistency.

[0044] Candidate solution B: "Introduce Redis as a distributed caching layer". Its characteristic vector FB shows that it has good data consistency and strong scalability, but the development and maintenance costs are high.

[0045] The system will then output different intelligent sorting results based on the input project requirement context labels: Scenario 1 (E-commerce startup project, aiming for rapid launch): After receiving context labels such as "startup" and "rapid iteration," the dynamic feature weighted network outputs a weight vector W that emphasizes cost features (cost_metrics). This is achieved by F′=W. After weighted calculation, the LambdaMART model gives option A a higher ranking score and places it first in the recommendation list.

[0046] Scenario 2 (Large-scale financial core system, pursuing extreme stability): After receiving contextual labels such as "finance" and "high availability," the dynamic feature weighted network outputs a weight vector W that allocates the maximum weight to risk features (risk_metrics) and quality features. After weighted calculation, the LambdaMART model determines that the data inconsistency risk of Scheme A is unacceptable in the financial scenario, assigns Scheme B the highest ranking score, and places it first in the recommendation list.

[0047] The following examples, using the sorting results obtained above, illustrate steps S51-S53: In the "financial sector" scenario, the system initially recommended "candidate solution A (Guava local cache)" to multiple teams. However, during actual development, several financial teams found that the data consistency of this solution was poor, and all responded with "disagree (-1)". As the feedback accumulated, the credibility of solution A in the "financial" scenario continued to decline, eventually reaching the trigger threshold of -100. After the system captured this threshold trigger signal, it packaged the feature vector of solution A in this scenario into negative samples and sent them to the "training pool".

[0048] When the automatic fine-tuning process starts over the weekend, the LambdaMART ranking model learns from the negative sample and grasps new empirical rules: in a financial scenario, candidate solution A is not recommended. The next time a new financial team inputs the same performance requirements, the iteratively evolved model will automatically lower the ranking of solution A and prioritize recommending "candidate solution B (Redis distributed cache)," thus achieving the collective accumulation and automated inheritance of expert implicit experience.

[0049] The working principle of this invention is as follows: First, the original requirement document is converted into a sentence dataset. Then, the sentence dataset is parsed to determine the structured NFR objects corresponding to entities, relations, and hierarchical intents. This allows the original requirement document to be decomposed into sentences, and then the sentences to be decomposed into NFR objects corresponding to entities, relations, and hierarchical intents, providing an accurate basis for subsequent computational parsing. Candidate solutions are searched for based on the structured NFR objects, and then feature vectors are constructed for the candidate solutions. The feature vectors focus on solution quality and maintenance cost. Then, the contextual labels of the candidate solutions are input into a dynamic feature weighting network to determine the weights corresponding to the feature vectors. This determines the final ranking scheme based on multiple aspects such as solution quality and maintenance cost in the feature vectors, thereby enabling... The system provides recommendation reports corresponding to different concerns regarding solution quality and maintenance costs. This is achieved through a single original document, without requiring users to input specific keywords. User interactions based on these reports are transformed into feedback signals, continuously receiving evaluation information from real-world usage environments. This feedback is used to train and re-rank the recommendation reports, ensuring that user feedback influences subsequent reports and leads to accurate recommendations. This closed-loop analysis system reduces reliance on manual analysis experience, lowers the cost and time of requirement processing and solution recommendation, and continuously improves the system's analytical capabilities, enabling the collective accumulation and automated transfer of expert tacit knowledge.

Claims

1. A deep learning-based method for analyzing non-functional requirements of software, characterized by: Includes the following steps: S1. Collect one or more original requirement documents containing natural language, preprocess them, and transform the original requirement documents into sentence datasets. S2. Perform semantic parsing on the sentence dataset to form structured NFR objects; S3. For the structured NFR object that triggers the processing, search and determine the candidate solution corresponding to the structured NFR object. Extract the contextual label from the original requirement document solution and combine it with the current NFR object to construct a feature vector. The feature vector includes the quality of the candidate solution and the maintenance cost. According to the label corresponding to the feature vector in the contextual label of the candidate solution, input it into the dynamic feature weighting network to determine the weight of the feature vector. The feature vector and the weight are weighted to obtain the weighted feature vector. The weighted feature vector is then input into the ranking learning model for training to output the final ranking score and the corresponding recommendation report. S4. Output a recommendation report corresponding to the selected information based on the selected information; S5. Continuously receive feedback information. After the accumulated feedback information reaches a preset value, add the weighted feature vector corresponding to the feedback information to the incremental data of the training pool. Then, through the incremental data of the training pool and the weighted feature vector, train the ranking learning model and update the final training output.

2. The method for analyzing non-functional requirements of software based on deep learning according to claim 1, characterized in that: The preprocessing in step S1 includes S11-S14: S11. Based on the original requirements document, extract all text content from the original requirements document; S12. Eliminate structural noise, delete content-level noise, and normalize full-width English characters to half-width lowercase characters to obtain clean text; S13. The clean text is processed through two-stage intelligent sentence segmentation. The two-stage intelligent sentence segmentation includes the collaborative work of a rule engine and a CRF model to identify period segmentation points and split the clean text into two independent sentences to form an initial sentence dataset. S14. The initial sentence dataset is processed through a three-stage lexical analysis to form a sentence dataset. The three-stage lexical analysis includes a first stage, a second stage, and a third stage. In the first stage, the domain dictionary is used to perform the best match on the core terms and verb-object phrases to form domain terms. In the second stage, the domain terms are fused and segmented using a CRF model to complete basic segmentation. After the basic segmentation is completed, the third stage performs syntactic analysis on the basic segmentation structure. If the probability of the syntactic tree is lower than a preset threshold, the abnormal segments are re-segmented.

3. The method for analyzing non-functional requirements of software based on deep learning according to claim 1, characterized in that: Step S2 includes S21-S23. S21: Perform deep semantic parsing on sentences in each sentence dataset using a ternary joint learning model. S22: Extract structured NFR objects of entities, relations and hierarchical intents from sentences by performing three sub-tasks in parallel: named entity recognition, relation extraction and hierarchical intent classification.

4. The method for analyzing non-functional requirements of software based on deep learning according to claim 1, characterized in that: Step S3 further includes: when a contacted NFR object is triggered, a ranking recommendation report is formed through a multi-parallel recall stage and an adaptive fusion ranking stage. The multi-parallel recall stage searches for candidate solutions through three channels: semantic vector, keywords, and collaborative filtering. The adaptive fusion ranking stage uses a dynamic feature weighting network to determine the weights corresponding to the feature vectors based on the item context labels, and determines the weighted feature vectors based on the feature vectors and weights. Finally, the ranking is determined based on the weighted feature vectors and a recommendation report is output.

5. The method for analyzing non-functional requirements of software based on deep learning according to claim 1, characterized in that: The adaptive ranking stage of candidate solutions in step S3 includes S31-S33: S31. Extract the document attributes of the candidate solutions and construct the feature vector F by combining them with the current NFR object; S32. Input the contextual labels of the current original requirements document into the dynamic feature weighting network, and output the feature vector W weights through the dynamic feature weighting network; S33, LambdaMART model scoring and ranking: The feature vector F and the feature weight vector W are multiplied element-wise to obtain the context-aware weighted feature vector F′, as shown in formula (1). F′=W*F (1) The weighted feature vector F′ is input into the pre-trained ranking learning model LambdaMART, and the LambdaMART model calculates the final ranking score for each candidate solution. The solutions are then sorted in descending order based on the scores to generate and output a technical solution recommendation report.

6. The method for analyzing non-functional requirements of software based on deep learning according to claim 1, characterized in that: Step S4 includes: receiving user selection information, determining the selection information of the recommendation report corresponding to the final ranking, and displaying the corresponding recommendation report according to the selection information.

7. The method for analyzing non-functional requirements of software based on deep learning according to claim 1, characterized in that: Step S5 includes S51-S53: S51. Obtain user feedback information from the log message queue, locate the feature vector corresponding to the feedback information, and update the current reputation of the feature vector using an exponential moving average algorithm with time decay, as shown in formula (2). Current credit rating = (Previous period credit rating × decay factor δ) + (1 - δ) × (weight ω × feedback information) (2); S52, When the absolute value reaches the preset trigger threshold, training samples are generated. The training samples include positive enhancement samples and negative suppression samples. S53. Automatically start the machine learning operation and maintenance pipeline based on Kubeflow according to the preset time period, and fine-tune the learning model LambdaMART based on the training samples.

8. A software non-functional requirements analysis system based on deep learning, used to implement the requirements analysis method according to any one of claims 1-6, characterized in that: It includes a preprocessing module, an extraction module, an NFR database, a technical solution knowledge base, a recommendation engine, an output module, a feedback module, and an optimization module; The preprocessing module is used to receive one or more original requirement documents containing natural language and preprocess them to transform the original requirement documents into sentence datasets. The extraction module is used to perform semantic parsing on the sentence dataset to form structured NFR objects; The NFR database is used to receive and store structured NFR objects and to create indexes. The technical solution knowledge base is used to define the static attributes, applicability rules, and relationships of technical solutions; The recommendation engine includes a sorting module, which is used to search for and sort candidate solutions. The output module is used to search and determine candidate solutions corresponding to the structured NFR object that triggers the processing, extract contextual labels from the original requirement document solution, and construct feature vectors in combination with the current NFR object. The feature vectors include the quality of the candidate solution and the maintenance cost. Based on the labels corresponding to the feature vectors in the contextual labels of the candidate solutions, the weights corresponding to the feature vectors are input into a dynamic feature weighting network to determine the weights of the feature vectors. The feature vectors and weights are weighted to obtain a weighted feature vector. The weighted feature vectors are then input into a ranking learning model for training to output the final ranking score and a corresponding recommendation report. The feedback module is used to obtain feedback information; The optimization module is used to process the feedback information and iteratively update the output module.

9. The software non-functional requirements analysis system based on deep learning according to claim 7, characterized in that: The extraction module includes a first decoding head, a second decoding head, and a third decoding head. The first decoding head is used for named entity recognition, extracting atomic information that constitutes the NFR by labeling BIOES entity tags. The second decoding head is used for relation extraction, identifying the inherent logical relationships between entities by constructing entity pair fusion vectors and inputting them into a multilayer perceptron (MLP) classifier to form structured triples. The third decoding head is used for intent classification, performing a global one-time prediction using the sigmoid activation function to determine the complete hierarchical path of the demand in the predefined intent tree.

10. The software non-functional requirements analysis system based on deep learning according to claim 7, characterized in that: The feedback information includes positive feedback information and negative feedback information.

Images