Man-machine conversation-based software cost intelligent evaluation interaction method and system

Abstract

The application provides a software cost intelligent evaluation interaction method and system based on human-computer conversation, relates to the technical field of software cost evaluation, and comprises the following steps: obtaining project description information, performing intention recognition and entity extraction, combining a knowledge graph to perform semantic matching to obtain a candidate cost reference, generating an estimated benchmark value based on multidimensional similarity calculation and weight self-adaptive adjustment, and supporting user feedback correction, so that accurate evaluation and dynamic adjustment of software cost are realized, and the accuracy, transparency and efficiency of software cost evaluation are improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of software cost evaluation, and in particular to a software cost intelligent evaluation interaction method and system based on human-computer dialogue. BACKGROUND

[0002] Software project cost evaluation is a key link in the software development process, directly affecting project budget planning and resource allocation decisions. With the rapid development of information technology, software project size and complexity are increasing, and traditional cost evaluation methods are difficult to meet the needs of modern software development. Currently, software cost evaluation mainly relies on expert experience judgment, parameterized model calculation and historical case analogy methods. Among them, the evaluation method based on historical cases is widely used in practice due to its intuitiveness and interpretability. This method analyzes the cost data of similar projects in history, combines the characteristics of the current project, and predicts the cost of the new project. In recent years, with the progress of artificial intelligence and natural language processing technology, intelligent evaluation systems based on dialogue have gradually become a research hotspot. Such systems can obtain project information through human-computer interaction, and use knowledge graph and semantic analysis technology to improve the accuracy and efficiency of evaluation.

[0003] Traditional software cost evaluation methods have limited processing capabilities for user-described project information, making it difficult to accurately identify and extract key functional requirements and non-functional constraints, resulting in insufficient understanding of project complexity and affecting the accuracy of evaluation results. In particular, when users use non-standardized or ambiguous language to describe requirements, the system has difficulty in effective semantic understanding and structured processing. Existing evaluation systems usually use fixed weight similarity calculation methods when matching historical cases, which cannot dynamically adjust the importance of each dimension factor according to the characteristics of different projects, resulting in a large deviation between the screening results of similar cases and the actual situation when facing diversified software projects, reducing the accuracy and reliability of cost evaluation. The existing technology lacks an effective feedback adjustment mechanism. When users question or correct the evaluation results, the system cannot quickly identify the root cause of the cost deviation, nor can it accurately incrementally adjust the evaluation model based on user feedback, which not only reduces the interaction efficiency of the evaluation process, but also limits the self-optimization ability of the system, making it difficult to meet the individual needs of specific projects. SUMMARY

[0004] The embodiment of the present application provides a software cost intelligent evaluation interaction method and system based on human-computer dialogue, which can solve the problems in the prior art.

[0005] In a first aspect, the embodiment of the present application provides a software cost intelligent evaluation interaction method based on human-computer dialogue, comprising:

[0006] Obtaining software project description information of a user, performing intent recognition and entity extraction on the software project description information to obtain a function module identifier, a business complexity feature, and a non-functional constraint, and constructing a project requirement element set;

[0007] According to the function module identifier, performing semantic matching on the project requirement element set and a pre-constructed software cost knowledge graph to establish an association relationship between requirement elements and historical cost cases, and obtaining a candidate cost reference set;

[0008] Based on the business complexity feature and the non-functional constraint, calculating the similarity of each dimension of each historical cost case in the candidate cost reference set, adaptively adjusting the weight of each dimension according to the matching degree of the current project requirement element and the historical case in each dimension, fusing the similarity based on the adjusted weight, and performing screening and aggregation operation on the candidate cost reference set to generate a cost estimation benchmark value;

[0009] Converting the cost estimation benchmark value into a cost evaluation result and presenting it to the user, receiving a feedback correction instruction of the user for the cost evaluation result, identifying a cost deviation source based on the feedback correction instruction, and mapping the cost deviation source to an incremental update operation on the project requirement element set, performing the incremental update operation and delivering the updated cost evaluation result to the user.

[0010] Performing intent recognition and entity extraction on the software project description information to obtain a function module identifier, a business complexity feature, and a non-functional constraint, and constructing a project requirement element set includes:

[0011] Performing syntax analysis and semantic segmentation on the software project description information, segmenting the software project description information into functional description segments, modifying description segments, and constraint description segments, identifying an intent type representing the user's cost evaluation target, and determining the target range and priority strategy of subsequent entity extraction according to the intent type;

[0012] Based on the target range and priority strategy, performing entity boundary recognition and type labeling on the functional description segments to extract the function module identifier, performing semantic understanding on the modifying description segments to identify the business complexity feature reflecting the implementation difficulty, and performing condition extraction on the constraint description segments to identify the non-functional constraint;

[0013] Organizing the function module identifier, the business complexity feature, and the non-functional constraint according to the structured template corresponding to the intent type, establishing an association index between the function module identifier and the business complexity feature, establishing an influence mapping relationship of the non-functional constraint on the function module identifier, and constructing a hierarchical project requirement element set.

[0014] performing semantic matching on the item requirement element set and a pre-built software cost knowledge graph to establish an association relationship between the requirement elements and historical cost cases, and obtaining a candidate cost reference set includes:

[0015] obtaining function entities, technology entities and cost entities of a plurality of historical cost cases and association relationships therebetween, and constructing the software cost knowledge graph;

[0016] mapping the module name and the module function attribute in the function module identifier and the function entities of each historical cost case into a vector space, and calculating a matching degree between the function module identifier and the function entities of each historical cost case based on a semantic distance in the vector space;

[0017] filtering out historical cost cases with a matching degree exceeding a preset dynamic threshold as a preliminary candidate set, and for the preliminary candidate set, tracing a technology implementation path, an implementation environment condition and a cost composition element associated with the historical cost case from the software cost knowledge graph; establishing an association relationship between the business complexity feature and the technology entity based on the technology implementation path, establishing an association relationship between the non-functional constraint and the technology entity based on the implementation environment condition, and obtaining a multi-level association relationship;

[0018] filtering and sorting the preliminary candidate set according to an association strength of the multi-level association relationship, retaining historical cost cases with an association strength satisfying a preset condition and extracting the cost entity according to the cost composition element, and forming the candidate cost reference set.

[0019] mapping the module name and the module function attribute in the function module identifier and the function entities of each historical cost case into a vector space, and calculating a matching degree between the function module identifier and the function entities of each historical cost case based on a semantic distance in the vector space includes:

[0020] extracting the module name and the module function attribute in the function module identifier and concatenating them to form a function module description text, extracting the function module name and the function attribute value corresponding to the function entities of each historical cost case from the software cost knowledge graph, and concatenating them to form a historical function description text;

[0021] performing semantic coding on the function module description text to obtain a function module vector, performing semantic coding on the historical function description text to obtain a historical function vector corresponding to each historical cost case, and mapping the function module vector and each historical function vector into a unified vector space;

[0022] In the vector space, the vector distance between the functional module vector and each historical functional vector is calculated. The vector distance is converted into a semantic distance. Based on the semantic distance, the matching degree between the functional module identifier and the functional entity of each historical cost case is calculated. The matching degree is negatively correlated with the semantic distance.

[0023] Based on the aforementioned business complexity characteristics and non-functional constraints, the similarity of each dimension of historical cost cases in the candidate cost reference set is calculated. The weights of each dimension are adaptively adjusted according to the matching degree between the current project requirements and historical cases in each dimension, including:

[0024] The business complexity features are divided into functional complexity dimension and data complexity dimension, and the non-functional constraints are divided into performance constraint dimension and environmental constraint dimension. The similarity between each historical cost case in the candidate cost reference set and the current project requirement element set in terms of functional complexity dimension, data complexity dimension, performance constraint dimension and environmental constraint dimension is calculated to obtain the initial similarity of each dimension.

[0025] For each historical cost case, the distribution characteristics of their initial similarity in each dimension are statistically analyzed. Based on the distribution characteristics, the dimensions with a discrimination ability higher than the preset discrimination threshold for the current project requirement element set are identified and assigned dynamic weights higher than the benchmark value. Dimensions with a discrimination ability lower than the preset discrimination threshold are assigned dynamic weights lower than the benchmark value. The value of the dynamic weight is positively correlated with the variance value of the corresponding dimension.

[0026] The similarity is fused based on the adjusted weights, and the candidate cost reference set is filtered and aggregated to generate a cost estimation benchmark value, including:

[0027] The adjusted weights are combined with the initial similarity of the corresponding dimensions to obtain the comprehensive similarity of each historical cost case in the candidate cost reference set. The historical cost cases are then sorted in descending order based on the comprehensive similarity.

[0028] A comprehensive similarity threshold is set, and historical cost cases with a comprehensive similarity higher than the comprehensive similarity threshold are selected from the sorted historical cost cases to form a high similarity case subset;

[0029] The cost entities corresponding to the high-similarity case subset are extracted from the software cost knowledge graph. The actual cost values ​​in the cost entities are obtained. The similarity normalization coefficient is calculated based on the comprehensive similarity of each historical cost case. The actual cost values ​​and the corresponding similarity normalization coefficients are aggregated to obtain the cost estimation benchmark value.

[0030] The cost estimation benchmark value is converted into a cost assessment result and presented to the user. Feedback and correction instructions from the user regarding the cost assessment result are received. Based on these feedback and correction instructions, sources of cost deviation are identified, including:

[0031] Extract the cost components corresponding to the cost estimation benchmark value, obtain the cost item values ​​of each cost component, and combine the cost estimation benchmark value and the cost item values ​​to generate a cost assessment result that includes the total cost and the item costs.

[0032] Receive feedback correction instructions from users regarding the cost assessment results, and parse the correction intent and correction object in the feedback correction instructions. The correction object includes the overall cost correction object and the itemized cost correction object.

[0033] When the correction intention is a deviation tracing operation, the type of the correction object is determined. When the correction object is an overall cost correction object, the source of the cost deviation is located to the adjusted weight and the comprehensive similarity threshold. When the correction object is a sub-item cost correction object, the cost component entity corresponding to the sub-item cost correction object is extracted. The business complexity feature nodes and non-functional constraint nodes associated with the cost component entity in the software cost knowledge graph are queried. The source of the cost deviation is located to the feature extraction process corresponding to the business complexity feature nodes and the non-functional constraint nodes.

[0034] A second aspect of the present invention provides a software cost intelligent evaluation interactive system based on human-computer dialogue, comprising:

[0035] The first unit is used to obtain the user's software project description information, perform intent recognition and entity extraction on the software project description information, obtain functional module identifiers, business complexity characteristics and non-functional constraints, and construct a set of project requirement elements.

[0036] The second unit is used to perform semantic matching between the set of project requirement elements and the pre-built software cost knowledge graph based on the functional module identifier, establish the association between the requirement elements and historical cost cases, and obtain a candidate cost reference set.

[0037] The third unit is used to calculate the similarity of each dimension of each historical cost case in the candidate cost reference set based on the business complexity characteristics and the non-functional constraints. Based on the matching degree between the current project requirements and historical cases in each dimension, the weight of each dimension is adaptively adjusted. The similarity is fused based on the adjusted weights, and the candidate cost reference set is screened and aggregated to generate a cost estimation benchmark value.

[0038] The fourth unit is used to convert the cost estimation benchmark value into a cost assessment result and present it to the user, receive feedback correction instructions from the user regarding the cost assessment result, identify the source of cost deviation based on the feedback correction instructions, map the source of cost deviation to an incremental update operation on the set of project requirement elements, execute the incremental update operation, and deliver the updated cost assessment result to the user.

[0039] A third aspect of the present invention,

[0040] An electronic device is provided, comprising:

[0041] processor;

[0042] Memory used to store processor-executable instructions;

[0043] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0044] Fourth aspect of the embodiments of the present invention,

[0045] A computer-readable storage medium is provided, having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0046] The beneficial effects of this application are as follows:

[0047] The intelligent interactive method for software cost assessment based on human-computer dialogue provided by this invention extracts functional module identifiers, business complexity characteristics and non-functional constraints from software project description information to construct a complete set of project requirement elements. This solves the problem of assessment bias caused by incomplete requirement information in traditional software cost estimation and improves the comprehensiveness and accuracy of requirement analysis.

[0048] This invention associates project requirement elements with a pre-built software cost knowledge graph through semantic matching, and adaptively adjusts the weights of each dimension based on business complexity characteristics and non-functional constraints. This enables intelligent screening and aggregation of candidate cost cases, overcoming the lack of flexibility caused by fixed weights in traditional methods, and making the cost estimation results more consistent with the actual characteristics and complexity of the project.

[0049] This invention designs an iterative optimization mechanism for cost assessment based on user feedback, which can identify the sources of cost deviations and automatically map them to incremental update operations of project requirement elements. This realizes human-computer collaboration and continuous optimization in the cost assessment process, effectively improving the interactive efficiency and assessment accuracy of software cost assessment, while accumulating richer cost knowledge and promoting the continuous evolution of the assessment model. Attached Figure Description

[0050] Figure 1This is a flowchart illustrating the intelligent software cost assessment interaction method based on human-computer dialogue, as described in an embodiment of the present invention.

[0051] Figure 2 A schematic diagram of the process for intelligent analysis of software project information and construction of requirement elements. Detailed Implementation

[0052] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0053] The technical solution of the present invention will be described in detail below with reference to specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0054] Figure 1 This is a flowchart illustrating the intelligent software cost assessment interaction method based on human-computer dialogue, as described in an embodiment of the present invention. Figure 1 As shown, the method includes:

[0055] Obtain the user's software project description information, perform intent recognition and entity extraction on the software project description information to obtain functional module identifiers, business complexity characteristics and non-functional constraints, and construct a set of project requirement elements;

[0056] Based on the functional module identifier, the set of project requirement elements is semantically matched with the pre-built software cost knowledge graph to establish the association between the requirement elements and historical cost cases, thereby obtaining a candidate cost reference set;

[0057] Based on the business complexity characteristics and the non-functional constraints, the similarity of each historical cost case in the candidate cost reference set is calculated in each dimension. According to the matching degree between the current project requirements and historical cases in each dimension, the weight of each dimension is adaptively adjusted. The similarity is fused based on the adjusted weights, and the candidate cost reference set is filtered and aggregated to generate a cost estimation benchmark value.

[0058] The cost estimation benchmark is converted into a cost assessment result and presented to the user. Feedback correction instructions from the user regarding the cost assessment result are received. Based on the feedback correction instructions, the source of cost deviation is identified, and the source of cost deviation is mapped to an incremental update operation on the set of project requirement elements. The incremental update operation is executed, and the updated cost assessment result is delivered to the user.

[0059] In one optional implementation, intent recognition and entity extraction are performed on the software project description information to obtain functional module identifiers, business complexity characteristics, and non-functional constraints, which are then constructed into a set of project requirement elements, including:

[0060] The software project description information is subjected to syntactic analysis and semantic segmentation, and is divided into functional description fragments, decorative description fragments and constraint description fragments. The intent type representing the user's cost assessment goal is identified, and the target scope and priority strategy for subsequent entity extraction are determined based on the intent type.

[0061] Based on the target scope and priority strategy, entity boundary identification and type labeling are performed on the functional description fragments to extract the functional module identifiers; semantic understanding is performed on the decorative description fragments to identify the business complexity features that reflect the implementation difficulty; and condition extraction is performed on the constraint description fragments to identify the non-functional constraints.

[0062] The functional module identifier, the business complexity feature, and the non-functional constraint are organized according to the structured template corresponding to the intent type. An association index is established between the functional module identifier and the business complexity feature. The influence mapping relationship of the non-functional constraint on the functional module identifier is established, and a hierarchical set of project requirement elements is constructed.

[0063] like Figure 2 As shown, the method includes:

[0064] The system receives user-input project description text, such as "Develop an e-commerce platform that supports user registration, product browsing, and online payment functions, with a response time of no more than 2 seconds and the ability to support 1000 simultaneous online users." Using dependency parsing, it identifies the subject-verb-object structure of the sentence and decomposes the description into basic semantic units. For the example above, "Develop an e-commerce platform" is identified as the core theme, "support user registration," "product browsing," and "online payment function" as functional description fragments, and "response time of no more than 2 seconds" and "support 1000 simultaneous online users" as constraint description fragments.

[0065] During intent recognition, a pre-trained intent classification model analyzes the text. This model, based on a deep learning architecture, takes a sequence of word vectors from the project description text as input and outputs a probability distribution of intent types. In the example above, the user intent was identified as "functionality implementation cost assessment." Therefore, the priority strategy for entity extraction is determined as: functional modules > business complexity > non-functional constraints. The intent recognition results guide the focus of subsequent processing.

[0066] Based on the defined target scope and priority strategy, entity extraction is performed on functional description fragments. For the fragment "supports user registration, product browsing, and online payment functions", named entity recognition technology is used to identify three functional module identifiers: "user registration module", "product browsing module", and "online payment module". Entity boundary recognition is achieved through a bidirectional long short-term memory network. The input of this network is a sequence of word vectors for the sentence, and the output is an entity label for each word. For the identified entities, their function type is further determined through rule matching and semantic understanding, such as labeling "online payment" as "transaction processing function".

[0067] For processing descriptive fragments, business complexity features are extracted. For example, in the description of "e-commerce platform," semantic understanding technology identifies that the platform belongs to the "e-commerce" domain, with a complexity level of "medium," requiring the integration of multiple business processes. An attention-based text classification model is then used to extract information representing complexity from the modifiers. For instance, for modifiers such as "multi-channel," "real-time," and "intelligent recommendation," they are identified as corresponding to the features of "high integration complexity," "high performance requirements," and "high algorithm complexity," respectively.

[0068] For constraint description fragments, non-functional constraints are extracted. For the fragments "response time not exceeding 2 seconds" and "supports 1000 concurrent users," conditional extraction techniques are used to identify non-functional requirements of the "performance constraint" type, and key parameters are extracted: a maximum response time of 2 seconds and 1000 concurrent users. Rule-based and pattern-matching methods are used to identify constraint expressions and transform them into structured constraint representations. For example, "response time not exceeding 2 seconds" is parsed as {constraint type: "performance constraint", metric name: "response time", comparison operator: "≤", threshold: "2 seconds"}.

[0069] During the phase of constructing the project requirement set, the extracted functional module identifiers, business complexity characteristics, and non-functional constraints are linked and organized to establish an association index between functional modules and business complexity characteristics. For example, the "online payment module" is associated with characteristics such as "high security level" and "medium interaction complexity." These relationships are recorded through an association matrix, where each cell represents the association strength between a specific functional module and a specific complexity characteristic.

[0070] Establish a mapping relationship between the impact of non-functional constraints and functional modules. For example, map the constraint "response time not exceeding 2 seconds" to the "product browsing module" and the "online payment module", indicating that these modules need to meet the response time requirement. Use an impact propagation graph to represent this mapping relationship, where nodes represent functional modules and constraints, and edges represent the impact relationship and its degree.

[0071] Based on the intent type, an appropriate structured template is selected to organize all elements into a hierarchical set of project requirement elements. For the intent of "functional implementation cost assessment," a tree structure centered on functional modules is adopted, with each functional module as a first-level node, and its associated complexity features and affected non-functional constraints as second- and third-level nodes, respectively. This organization allows subsequent cost estimation algorithms to directly traverse this structure, calculate the implementation cost of each functional module, and summarize the results to obtain the overall project cost estimate.

[0072] Through the aforementioned technologies, key elements can be intelligently extracted from software project requirements described in natural language and a structured set of requirement elements can be constructed, providing a data foundation for cost assessment and development planning of software projects.

[0073] In one optional implementation, the set of project requirement elements is semantically matched with a pre-built software cost knowledge graph to establish the association between the requirement elements and historical cost cases, resulting in a candidate cost reference set including:

[0074] Obtain the functional entities, technical entities, and cost entities of multiple historical cost cases and their relationships, and construct the software cost knowledge graph.

[0075] The module name and module function attributes in the functional module identifier, as well as the functional entities of each historical cost case, are mapped to a vector space. The matching degree between the functional module identifier and the functional entities of each historical cost case is calculated based on the semantic distance in the vector space.

[0076] Historical cost cases with a matching degree exceeding a preset dynamic threshold are selected as a preliminary candidate set. For the preliminary candidate set, the technical implementation path, implementation environment conditions, and cost components associated with the historical cost cases are traced from the software cost knowledge graph. Based on the technical implementation path, the association between the business complexity characteristics and the technical entities is established, and based on the implementation environment conditions, the association between the non-functional constraints and the technical entities is established, resulting in a multi-level association relationship.

[0077] The preliminary candidate set is filtered and sorted according to the association strength of the multi-level relationships. Historical cost cases that meet the preset conditions are retained, and the cost entities are extracted according to the cost components to form the candidate cost reference set.

[0078] The software cost knowledge graph is constructed based on the functional entities, technical entities, and cost entities of multiple historical cost cases and their relationships. Specifically, for each historical cost case, information such as functional description, technical architecture, development environment, implementation conditions, and cost data is extracted. Functional entities include the names of each functional module and their corresponding functional attributes; technical entities include technical components such as programming languages, frameworks, databases, and middleware; and cost entities include components such as human resource costs, time costs, and resource costs. For example, for an enterprise resource management system, its functional entities may include "human resource management module," "financial management module," etc.; technical entities may include "three-tier architecture," "relational database," etc.; and cost entities may include "developer man-hours," "server costs," etc. These entities and their relationships are stored using a graph database, forming a multi-level knowledge network. In practical applications, this knowledge graph contains 500 historical cases, covering 10 major software project types, 20,000 functional entity nodes, 8,000 technical entity nodes, and 5,000 cost entity nodes.

[0079] When performing semantic matching between project requirements and historical cases, the module name and module functional attributes are extracted from the functional module identifier. These are then concatenated to form the functional module description text. For example, "Customer Management Module - Supports customer information maintenance, category management, and transaction record query" is transformed into "Customer Management Module, supports customer information maintenance, implements category management, and provides transaction record query function." Simultaneously, the functional module names and functional attribute values ​​corresponding to the functional entities in each historical cost estimation case are extracted from the software cost estimation knowledge graph and concatenated to form the historical functional description text.

[0080] A pre-trained semantic encoding model is invoked. The functional module description text is input into the pre-trained semantic encoding model to obtain functional module vectors. Similarly, the historical functional description texts of each historical cost case are input into the pre-trained semantic encoding model to obtain the corresponding historical functional vectors for each historical cost case. This model uses a 300-dimensional vector representation. The functional module vectors and the historical functional vectors are mapped to a unified vector space.

[0081] In the vector space, the vector distance between the functional module vector and each historical functional vector is calculated using the cosine distance method. The vector distance is then converted to semantic distance using the formula: Semantic distance = 1 - Cosine similarity, where cosine similarity = 1 - cosine distance. Based on the semantic distance, the matching degree between the functional module identifier and the functional entities in each historical cost case is calculated. The matching degree is negatively correlated with the semantic distance, and the calculation formula is: Matching degree = 1 - Semantic distance.

[0082] A dynamic threshold is set, which is dynamically adjusted based on the project type and scale, typically between 0.75 and 0.85. For example, for common enterprise information systems, the threshold can be set to 0.8; for specialized applications, it can be increased to 0.85 to ensure matching accuracy. For each functional module, historical cases with a matching degree exceeding the threshold are selected as initial candidates. In practical applications, a project containing 15 functional modules will generate approximately 50 initial candidate cases.

[0083] For the initial candidate set, the technical implementation path, implementation environment conditions, and cost components associated with each historical case are traced from the software cost knowledge graph. The technical implementation path includes technical architecture, development framework, and component dependencies; the implementation environment conditions include hardware requirements, deployment environment, and security level; and the cost components include personnel allocation, work hour distribution, and third-party service fees. A graph traversal algorithm is used to start from functional entities and query related technical and cost entities along the relationships. For example, for the "Customer Management Module," multiple technical implementation paths are traced, such as those based on relational databases and those based on non-relational databases.

[0084] The system establishes relationships between business complexity characteristics and technical entities. Business complexity characteristics include metrics such as data volume, concurrent users, and transaction complexity. By comparing the similarity of these characteristics between new projects and historical cases, a relationship is established between business complexity characteristics and technical entities. For example, a strong relationship is established between high-concurrency transaction processing requirements and technical entities employing a distributed architecture. The system also establishes relationships between non-functional constraints and technical entities. Non-functional constraints include performance requirements, security requirements, and scalability requirements. The degree of matching between the constraints of the new project and the implementation environment of historical cases is calculated, establishing a relationship between non-functional constraints and technical entities. Through these two steps, a multi-level relationship network is constructed, including relationships at the functional, technical, and cost levels.

[0085] The initial candidate set was filtered and sorted based on the strength of multi-level correlations. The correlation strength calculation comprehensively considered functional matching degree, technical path similarity, and environmental condition matching degree, and a weighted summation method was used to calculate the comprehensive score. The weight allocation was: functional matching degree 0.5, technical path similarity 0.3, and environmental condition matching degree 0.2. Historical cases with a comprehensive score exceeding 0.7 were retained and sorted from highest to lowest score. In one actual case, after multi-level correlation analysis, 15 highly relevant cases were retained from the initial 50 candidate cases as the final candidate cost reference set.

[0086] For the final candidate set, cost entities are extracted based on cost components, including labor costs, time costs, hardware costs, software licensing costs, and service costs. Cost data for these cases are retrieved from the knowledge graph and adjusted according to time and regional factors.

[0087] In one optional implementation, the module name and module functional attributes in the functional module identifier, as well as the functional entities of each historical cost case, are mapped to a vector space. The matching degree between the functional module identifier and the functional entities of each historical cost case is calculated based on the semantic distance in the vector space, including:

[0088] Extract the module name and module function attribute from the functional module identifier and concatenate them to form a functional module description text. Extract the functional module name and function attribute value corresponding to the functional entity of each historical cost case from the software cost knowledge graph and concatenate them to form a historical function description text.

[0089] The functional module description text is semantically encoded to obtain a functional module vector. The historical functional description text is semantically encoded to obtain a historical functional vector corresponding to each historical cost case. The functional module vector and each historical functional vector are mapped to a unified vector space.

[0090] In the vector space, the vector distance between the functional module vector and each historical functional vector is calculated. The vector distance is converted into a semantic distance. Based on the semantic distance, the matching degree between the functional module identifier and the functional entity of each historical cost case is calculated. The matching degree is negatively correlated with the semantic distance.

[0091] Extract the module name and functional attributes from the functional module identifier. For example, for the user-submitted functional module identifier "Enterprise Message Management System - Instant Messaging Module", the module name is "Instant Messaging Module", and the module functional attributes include "Message Sending and Receiving", "Group Management", and "File Transfer". Concatenate this information to form the functional module description text, such as "Instant Messaging Module, implements message sending and receiving functions, supports group management, and provides file transfer services". Simultaneously, extract functional entity information from historical cost estimation cases from the software cost knowledge graph. For example, for the "Communication Component" functional entity in the historical case "Enterprise Collaborative Office Platform", its name is "Communication Component", and its functional attribute values ​​include "Instant Message Processing", "Team Communication", and "Resource Sharing". Concatenate this information to form the historical functional description text, such as "Communication Component, provides instant message processing, supports team communication, and implements resource sharing functions".

[0092] A semantic encoding model is used to process the functional module description text, transforming the textual information into a high-dimensional vector representation. A pre-trained word embedding model is used here, trained on a large-scale software engineering corpus, capable of capturing the semantic information of software function descriptions. For the functional module description text "Instant messaging module, implements message sending and receiving functions, supports group management, and provides file transfer services," a 128-dimensional functional module vector is obtained through the semantic encoding model. Similarly, for the historical function description text "Communication component, provides instant messaging processing, supports team communication, and implements resource sharing functions," a 128-dimensional historical function vector is obtained through the same semantic encoding model.

[0093] To ensure consistency in vector representation, functional module vectors and historical functional vectors are mapped to a unified vector space. This step is achieved through vector normalization, which divides each vector by its magnitude, mapping all vectors to a unit hypersphere. This process makes the similarity calculation between vectors more accurate and unaffected by differences in vector length.

[0094] In a unified vector space, the vector distance between the functional module vector and each historical functional vector is calculated. The vector distance is calculated using the cosine distance method, which measures their similarity by calculating the cosine of the angle between two vectors. For example, a cosine distance of 0.15 between a functional module vector and a certain historical functional vector indicates a high similarity between them; while a cosine distance of 0.65 with another historical functional vector indicates a low similarity.

[0095] The vector distance is converted to semantic distance using the following method: Semantic distance = 1 - cosine similarity, where cosine similarity = 1 - cosine distance. In the example above, the first historical function vector has a cosine similarity of 0.85 and a semantic distance of 0.15; the second historical function vector has a cosine similarity of 0.35 and a semantic distance of 0.65.

[0096] Based on the calculated semantic distance, the matching degree between the functional module identifier and the functional entities in each historical cost case is further calculated. The matching degree is negatively correlated with the semantic distance, and the specific calculation formula is: Matching degree = 1 - Semantic distance. In the example above, the matching degree of the first historical functional entity is 0.85, and the matching degree of the second historical functional entity is 0.35. Based on the matching degree, the most similar historical cost case is recommended to the user.

[0097] In practical applications, a matching threshold of 0.7 is set, meaning only historical cost estimates with a matching score greater than or equal to 0.7 are recommended to the user. In the example above, a historical cost estimate with a matching score of 0.85 is recommended, while one with a matching score of 0.35 is not. This ensures that the recommended historical cost estimates are highly relevant to the user's current needs.

[0098] In one optional implementation, based on the business complexity characteristics and the non-functional constraints, the similarity of each dimension of historical cost cases in the candidate cost reference set is calculated. The weights of each dimension are adaptively adjusted according to the degree of matching between the current project requirements and historical cases in each dimension, including:

[0099] The business complexity features are divided into functional complexity dimension and data complexity dimension, and the non-functional constraints are divided into performance constraint dimension and environmental constraint dimension. The similarity between each historical cost case in the candidate cost reference set and the current project requirement element set in terms of functional complexity dimension, data complexity dimension, performance constraint dimension and environmental constraint dimension is calculated to obtain the initial similarity of each dimension.

[0100] For each historical cost case, the distribution characteristics of their initial similarity in each dimension are statistically analyzed. Based on the distribution characteristics, the dimensions with a discrimination ability higher than the preset discrimination threshold for the current project requirement element set are identified and assigned dynamic weights higher than the benchmark value. Dimensions with a discrimination ability lower than the preset discrimination threshold are assigned dynamic weights lower than the benchmark value. The value of the dynamic weight is positively correlated with the variance value of the corresponding dimension.

[0101] Business complexity features are divided into functional complexity and data complexity dimensions. For the functional complexity dimension, the main considerations are the matching between the current project and historical cases in terms of the number of business processes, the complexity of business process steps, and the number of business rules. For example, for a sales management system, if the current project includes three main business processes—order management, inventory management, and customer management—each with an average of 8 steps, and historical case A includes two business processes—order management and inventory management—each with an average of 6 steps, then the functional coverage rate can be calculated to be 66.7% (2 / 3), the step complexity matching degree is 75% (6 / 8), and the overall initial similarity of the functional complexity dimension is 70.85%.

[0102] For the data complexity dimension, factors such as the number of entities, the number of attributes, and the complexity of entity relationships are mainly considered. For example, the current project contains four core entities: customers, products, orders, and payment records, totaling 40 key attributes, with 6 types of relationships between entities. Historical case B contains three entities: customers, products, and orders, totaling 32 key attributes, with 4 types of relationships between entities. Thus, the entity coverage rate is 75% (3 / 4), the attribute coverage rate is 80% (32 / 40), and the relationship complexity matching degree is 66.7% (4 / 6). The overall calculation yields an initial similarity of 73.9% for the data complexity dimension.

[0103] The non-functional constraints are divided into performance constraints and environmental constraints. For performance constraints, the main considerations are concurrent users, response time requirements, and transaction volume. For example, the current project requires support for 500 concurrent users, a critical business response time of no more than 1.5 seconds, and a daily transaction volume of 100,000. Historical case C supported 400 concurrent users, a critical business response time of no more than 2 seconds, and a daily transaction volume of 80,000. Therefore, the matching degree for concurrent users is 80% (400 / 500), the matching degree for response time is 75% (1.5 / 2), and the matching degree for transaction volume is 80% (8 / 10). The overall initial similarity for the performance constraint dimension is calculated to be 78.3%.

[0104] For the environmental constraints dimension, factors such as technology stack compatibility, deployment environment requirements, and security level requirements are mainly considered. For example, the current project uses a Java technology stack and needs to be deployed in a private cloud environment with a security level requirement of level three. In contrast, historical case D uses a Java technology stack and is deployed in a hybrid cloud environment with a security level requirement of level four. Therefore, the technology stack compatibility is 100%, the deployment environment matching degree is 80%, and the security level matching degree is 75%. The overall calculation yields an initial similarity of 85% for the environmental constraints dimension.

[0105] For all historical cases in the candidate cost reference set, we statistically analyze the distribution characteristics of their initial similarity across various dimensions, especially calculating the variance of the similarity across each dimension. For example, for a candidate cost reference set containing 10 historical cases, assuming the initial similarity distribution of the functional complexity dimension is: {70.85%, 65.2%, 82.3%, 72.5%, 91.2%, 68.7%, 74.3%, 88.6%, 63.9%, 79.4%}, the calculated variance is 85.27; the initial similarity distribution of the data complexity dimension is: {73.9%, 75.2%, 78.1%, 72.6%, 74.8%, 73.5%, 76.2%, 75.9%, 74.3%, 77.8%}, the calculated variance is 3.12; and the initial similarity distribution of the performance constraint dimension is: {78.3%, 65.7%, 83.2%, 72.5%, 81.6%, 69.3%, 75.8%, 82.4%, 68.9%}. The initial similarity distribution of the environmental constraint dimension is {85%, 62.3%, 91.5%, 73.8%, 88.2%, 70.6%, 82.1%, 89.7%, 68.4%, 80.3%}, with a calculated variance of 98.63.

[0106] The preset discrimination threshold is set to 25, and the baseline weight is 0.25, meaning the weights are evenly distributed across the four dimensions. Since the variances of the functional complexity and environmental constraints dimensions are 85.27 and 98.63 respectively, both greater than the preset discrimination threshold of 25, it indicates that these two dimensions have a high discrimination ability for the current project's requirement set and should be assigned dynamic weights higher than the baseline value. The variance of the data complexity dimension is 3.12, less than the preset discrimination threshold, indicating that this dimension has a weaker discrimination ability for the current project and should be assigned a dynamic weight lower than the baseline value. The variance of the performance constraints dimension is 36.45, also higher than the preset discrimination threshold, and should similarly be assigned a dynamic weight higher than the baseline value.

[0107] Based on the proportional relationship between the variance values ​​of each dimension and the total variance, and ensuring that the sum of the weights is 1, the final weights are determined as follows: functional complexity dimension: 0.38; data complexity dimension: 0.14; performance constraint dimension: 0.16; and environmental constraint dimension: 0.32. This dynamic weight adjustment mechanism ensures that dimensions with stronger discriminative power receive higher weights during similarity calculation, thereby improving the accuracy and relevance of the overall similarity calculation and making the final selected reference cases more reflective of the actual situation of the current project.

[0108] In one optional implementation, the similarity is fused based on the adjusted weights, and the candidate cost reference set is filtered and aggregated to generate a cost estimation benchmark value, including:

[0109] The adjusted weights are combined with the initial similarity of the corresponding dimensions to obtain the comprehensive similarity of each historical cost case in the candidate cost reference set. The historical cost cases are then sorted in descending order based on the comprehensive similarity.

[0110] A comprehensive similarity threshold is set, and historical cost cases with a comprehensive similarity higher than the comprehensive similarity threshold are selected from the sorted historical cost cases to form a high similarity case subset;

[0111] The cost entities corresponding to the high-similarity case subset are extracted from the software cost knowledge graph. The actual cost values ​​in the cost entities are obtained. The similarity normalization coefficient is calculated based on the comprehensive similarity of each historical cost case. The actual cost values ​​and the corresponding similarity normalization coefficients are aggregated to obtain the cost estimation benchmark value.

[0112] The adjusted weights are then fused with the initial similarities for the corresponding dimensions to obtain the comprehensive similarity of each historical cost case in the candidate cost reference set. Assume a software project has three evaluation dimensions: number of feature points, development team size, and project duration, with adjusted weights of 0.5, 0.3, and 0.2, respectively. For a historical case A in the candidate set, its initial similarities on these three dimensions are 0.85, 0.72, and 0.90, respectively. Therefore, the comprehensive similarity of this case is calculated as 0.5 × 0.85 + 0.3 × 0.72 + 0.2 × 0.90 = 0.425 + 0.216 + 0.18 = 0.821. The same calculation is performed on all historical cases in the candidate set to obtain the comprehensive similarity value for each case.

[0113] After obtaining the comprehensive similarity score, the historical cost cases are sorted in descending order of comprehensive similarity. For example, assuming the candidate set contains 10 historical cases, the calculated comprehensive similarity scores are as follows: Case A (0.821), Case B (0.795), Case C (0.783), Case D (0.762), Case E (0.741), Case F (0.720), Case G (0.698), Case H (0.675), Case I (0.652), and Case J (0.631). These cases are then sorted from highest to lowest comprehensive similarity score as: A, B, C, D, E, F, G, H, I, and J.

[0114] After sorting, a comprehensive similarity threshold is set to filter high-similarity cases. In this embodiment, the threshold is set to 0.75. Cases with a comprehensive similarity higher than 0.75 are selected from the sorted historical cost cases to form a high-similarity case subset. According to the above example, the high-similarity case subset includes case A (0.821), case B (0.795), case C (0.783), and case D (0.762).

[0115] Cost entities corresponding to highly similar case subsets are extracted from the software cost knowledge graph. Each case is associated with an actual cost value in the knowledge graph. Assume the actual costs of cases A, B, C, and D obtained from the knowledge graph are 920,000 yuan, 880,000 yuan, 950,000 yuan, and 850,000 yuan, respectively.

[0116] To reasonably calculate the cost estimate based on the similarity of each historical case, a normalized similarity coefficient for each historical case is calculated. The normalization system calculates this by dividing the overall similarity of each case by the sum of the overall similarities of all selected cases. In this example, the sum of the overall similarities of the high-similarity case subset is 0.821 + 0.795 + 0.783 + 0.762 = 3.161. Therefore, the normalized coefficients for cases A, B, C, and D are 0.821 ÷ 3.161 = 0.260, 0.795 ÷ 3.161 = 0.251, 0.783 ÷ 3.161 = 0.248, and 0.762 ÷ 3.161 = 0.241, respectively.

[0117] The actual costs of each historical case are aggregated using a weighted average method with their corresponding similarity normalization coefficients. Specifically, the actual cost of each case is multiplied by its normalization coefficient, and then summed to obtain the final result. For this example, the cost estimation benchmark is calculated as follows: 92 × 0.260 + 88 × 0.251 + 95 × 0.248 + 85 × 0.241 = 23.92 + 22.09 + 23.56 + 20.49 = 90.06 million yuan.

[0118] This cost estimation benchmark reflects the costs of historical cases most similar to the target software project and is reasonably weighted according to the degree of similarity, thus providing a reliable reference for software project cost estimation. In practical applications, the similarity threshold can be adjusted according to the specific project characteristics and the amount of historical data to ensure that a sufficient number of representative high-similarity cases are selected.

[0119] The above steps facilitate the transformation from a candidate cost reference set to a cost estimation benchmark, providing a scientific and objective method for cost estimation in software projects. Because this method fully utilizes the similarities of historical cost cases and cost data from the software cost knowledge graph, it effectively improves the accuracy and reliability of software project cost estimation.

[0120] In one optional implementation, the cost estimation benchmark value is converted into a cost assessment result and presented to the user. Feedback correction instructions from the user regarding the cost assessment result are received. Based on the feedback correction instructions, the sources of cost deviation are identified, including:

[0121] Extract the cost components corresponding to the cost estimation benchmark value, obtain the cost item values ​​of each cost component, and combine the cost estimation benchmark value and the cost item values ​​to generate a cost assessment result that includes the total cost and the item costs.

[0122] Receive feedback correction instructions from users regarding the cost assessment results, and parse the correction intent and correction object in the feedback correction instructions. The correction object includes the overall cost correction object and the itemized cost correction object.

[0123] When the correction intention is a deviation tracing operation, the type of the correction object is determined. When the correction object is an overall cost correction object, the source of the cost deviation is located to the adjusted weight and the comprehensive similarity threshold. When the correction object is a sub-item cost correction object, the cost component entity corresponding to the sub-item cost correction object is extracted. The business complexity feature nodes and non-functional constraint nodes associated with the cost component entity in the software cost knowledge graph are queried. The source of the cost deviation is located to the feature extraction process corresponding to the business complexity feature nodes and the non-functional constraint nodes.

[0124] The cost components are extracted from the database, corresponding to the baseline cost estimate. These components include multiple dimensions such as development manpower costs, testing resource costs, and infrastructure costs. Taking an enterprise management system as an example, the cost components of the project are obtained from the software cost knowledge graph, including front-end development manpower costs of 1.2 million yuan, back-end development manpower costs of 1.8 million yuan, database design costs of 500,000 yuan, system testing costs of 600,000 yuan, and cloud server deployment costs of 400,000 yuan. The cost item values ​​of these cost components are obtained and combined with the overall cost estimate baseline of 4.5 million yuan to generate a complete cost assessment result. This result includes the overall cost and the costs of each item, and is presented to the user through the user interface.

[0125] After reviewing the cost assessment results, if users find some values ​​that do not meet expectations, they can input correction commands through the feedback mechanism provided on the interface. For example, a user might think that the total cost of 4.5 million yuan given by the system is too high and that the expected value should be 4 million yuan; or they might think that the backend development manpower cost of 1.8 million yuan is too high and that the reasonable value should be 1.5 million yuan. Upon receiving these feedback correction commands, natural language processing technology is used to analyze the correction intent and the object of correction in the commands.

[0126] Correction intentions typically include adjusting specific values, requesting explanations for deviations, and requesting deviation tracing operations. Correction targets are divided into overall cost correction targets and sub-item cost correction targets. Semantic analysis algorithms are used to identify keywords and grammatical structures in the instructions to extract the specific correction intentions and correction targets. For example, when a user inputs "The total cost should be reduced by 500,000 yuan, please analyze the reasons," the correction intention is parsed as "deviation tracing operation," the correction target is "overall cost," and the correction amount is "reduced by 500,000 yuan."

[0127] When the parsed correction intent is a deviation tracing operation, the type of the correction object is determined. If the correction object is an overall cost correction object, the source of the cost deviation is located to the adjusted weights and the comprehensive similarity threshold. The case retrieval process is then reviewed to examine the weight settings of each feature dimension in the case similarity calculation and the determination process of the comprehensive similarity threshold. For example, it was found that during the case matching process, the weight of the business complexity feature was set to 0.6, while the weight of the technical architecture feature was only 0.2. This caused the search results to be biased towards historical cases with similar business complexity but significantly different technical architectures, resulting in an overestimation of the estimated results. This finding was fed back to the user as a source of cost deviation.

[0128] If the correction target is a sub-item cost correction target, such as a user believing that the backend development labor cost is too high, the cost entity "backend development labor cost" corresponding to this sub-item cost correction target is extracted. The business complexity feature node and non-functional constraint node associated with this cost entity are then queried in the software cost knowledge graph. In the example, a strong correlation was found between the backend development labor cost and the "transaction processing complexity" feature node and the "high concurrency processing" non-functional constraint node. Further analysis revealed that during feature extraction, the project's transaction processing complexity was rated as "high," and the high concurrency processing requirement was also marked as "strict." This combination of features caused the system to use a higher workload coefficient in the labor cost estimation, resulting in an overestimation of the backend development labor cost.

[0129] These findings are fed back to users as sources of cost discrepancies, along with adjustment suggestions. For example, if a user confirms that the project's transaction processing complexity is actually at a "medium" level, the backend development manpower cost can be recalculated, resulting in a revised figure of 1.5 million yuan. Simultaneously, this correction process is recorded for future estimation and optimization of similar projects.

[0130] This approach effectively identifies sources of cost deviations and allows for continuous optimization of the cost assessment model based on user feedback, thereby improving the accuracy and interpretability of software project cost assessments.

[0131] A pre-trained large language model is used as the underlying semantic understanding engine. Through fine-tuning, it adapts to the specialized terminology and expressions used in the software cost estimation field. When a user inputs software project description information, the large model first performs semantic analysis, segmenting the description into functional, descriptive, and constraint fragments. For example, for the description "Developing an e-commerce platform requires integrating a third-party payment interface and supporting high-concurrency access," the large model accurately identifies "e-commerce platform" as the core theme, "integrating a third-party payment interface" as a functional description, and "supporting high-concurrency access" as a non-functional constraint.

[0132] The introduction of large models significantly enhances the system's ability to understand complex, unstructured text. Compared to traditional rule matching and shallow semantic analysis methods, large models can understand contextual relationships and implicit information, effectively identifying technical terms, business concepts, and technical requirements within the text. For example, when a description mentions "the need to implement product search functionality similar to mainstream e-commerce platforms," ​​the large model understands that this means supporting complex product categorization, filtering, sorting, and search recommendation functions, rather than simply keyword matching.

[0133] During the functional module identification extraction process, the large model can automatically identify and standardize the descriptions of functional modules based on domain knowledge. For the extraction of business complexity features, the large model can analyze the complexity information implied in modifiers and qualifiers, such as the implementation difficulty implied in expressions like "multi-level approval process" and "complex access control." For non-functional constraints, the large model can extract quantitative and qualitative constraints from the description and convert them into structured constraint representations.

[0134] By fine-tuning the contextual prompts of the large model (prompt engineering), the model is guided to focus on the key information required for software cost assessment, and its performance is continuously optimized through manual verification and feedback. Practice shows that the system after integrating the large model improves the accuracy of function identification and non-functional constraint identification when processing complex software project descriptions, significantly improving the quality of the basic data for software cost assessment.

[0135] This invention relates to an intelligent interactive system for software cost assessment based on human-computer dialogue, the system comprising:

[0136] The first unit is used to obtain the user's software project description information, perform intent recognition and entity extraction on the software project description information, obtain functional module identifiers, business complexity characteristics and non-functional constraints, and construct a set of project requirement elements.

[0137] The second unit is used to perform semantic matching between the set of project requirement elements and the pre-built software cost knowledge graph based on the functional module identifier, establish the association between the requirement elements and historical cost cases, and obtain a candidate cost reference set.

[0138] The third unit is used to calculate the similarity of each dimension of each historical cost case in the candidate cost reference set based on the business complexity characteristics and the non-functional constraints. Based on the matching degree between the current project requirements and historical cases in each dimension, the weight of each dimension is adaptively adjusted. The similarity is fused based on the adjusted weights, and the candidate cost reference set is screened and aggregated to generate a cost estimation benchmark value.

[0139] The fourth unit is used to convert the cost estimation benchmark value into a cost assessment result and present it to the user, receive feedback correction instructions from the user regarding the cost assessment result, identify the source of cost deviation based on the feedback correction instructions, map the source of cost deviation to an incremental update operation on the set of project requirement elements, execute the incremental update operation, and deliver the updated cost assessment result to the user.

[0140] A third aspect of the present invention provides an electronic device, comprising:

[0141] processor;

[0142] Memory used to store processor-executable instructions;

[0143] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0144] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0145] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0146] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A software cost intelligent assessment interactive method based on human-computer dialogue, characterized in that, include: Obtain the user's software project description information, perform intent recognition and entity extraction on the software project description information to obtain functional module identifiers, business complexity characteristics and non-functional constraints, and construct a set of project requirement elements; Based on the functional module identifier, the set of project requirement elements is semantically matched with the pre-built software cost knowledge graph to establish the association between the requirement elements and historical cost cases, thereby obtaining a candidate cost reference set; Based on the aforementioned business complexity characteristics and non-functional constraints, the similarity of each dimension of historical cost cases in the candidate cost reference set is calculated. The weights of each dimension are adaptively adjusted according to the matching degree between the current project requirements and historical cases in each dimension, including: The business complexity features are divided into functional complexity dimension and data complexity dimension, and the non-functional constraints are divided into performance constraint dimension and environmental constraint dimension. The similarity between each historical cost case in the candidate cost reference set and the current project requirement element set in terms of functional complexity dimension, data complexity dimension, performance constraint dimension and environmental constraint dimension is calculated to obtain the initial similarity of each dimension. For each historical cost case, the distribution characteristics of their initial similarity across various dimensions are statistically analyzed. Based on these distribution characteristics, dimensions with a discrimination ability higher than a preset discrimination threshold for the current project's requirement element set are identified and assigned dynamic weights higher than a benchmark value. Dimensions with a discrimination ability lower than the preset discrimination threshold are assigned dynamic weights lower than the benchmark value. The value of the dynamic weight is positively correlated with the variance value of the corresponding dimension. The similarity is fused based on the adjusted weights, and the candidate cost reference set is filtered and aggregated to generate a cost estimation benchmark value. The cost estimation benchmark is converted into a cost assessment result and presented to the user. Feedback correction instructions from the user regarding the cost assessment result are received. Based on the feedback correction instructions, the source of cost deviation is identified, and the source of cost deviation is mapped to an incremental update operation on the set of project requirement elements. The incremental update operation is executed, and the updated cost assessment result is delivered to the user.

2. The method according to claim 1, characterized in that, The software project description information is subjected to intent recognition and entity extraction to obtain functional module identifiers, business complexity characteristics, and non-functional constraints, which are then constructed into a set of project requirement elements, including: The software project description information is subjected to syntactic analysis and semantic segmentation, and is divided into functional description fragments, decorative description fragments and constraint description fragments. The intent type representing the user's cost assessment goal is identified, and the target scope and priority strategy for subsequent entity extraction are determined based on the intent type. Based on the target range and priority strategy, entity boundary identification and type labeling are performed on the functional description fragments, and the functional module identifiers are extracted. Perform semantic understanding on the modified description fragments to identify the business complexity features that reflect the implementation difficulty; Condition extraction is performed on the constraint description fragment to identify the non-functional constraints; The functional module identifier, the business complexity feature, and the non-functional constraint are organized according to the structured template corresponding to the intent type. An association index is established between the functional module identifier and the business complexity feature. The influence mapping relationship of the non-functional constraint on the functional module identifier is established, and a hierarchical set of project requirement elements is constructed.

3. The method according to claim 1, characterized in that, The project requirement element set is semantically matched with a pre-constructed software cost knowledge graph to establish the association between the requirement elements and historical cost cases, resulting in a candidate cost reference set including: Obtain the functional entities, technical entities, and cost entities of multiple historical cost cases and their relationships, and construct the software cost knowledge graph. The module name and module function attributes in the functional module identifier, as well as the functional entities of each historical cost case, are mapped to a vector space. The matching degree between the functional module identifier and the functional entities of each historical cost case is calculated based on the semantic distance in the vector space. Historical cost cases with a matching degree exceeding a preset dynamic threshold are selected as a preliminary candidate set. For the preliminary candidate set, the technical implementation path, implementation environment conditions and cost components associated with the historical cost cases are traced from the software cost knowledge graph. Based on the technical implementation path, establish the association between the business complexity characteristics and the technical entities; based on the implementation environment conditions, establish the association between the non-functional constraints and the technical entities, thus obtaining a multi-level association relationship. The preliminary candidate set is filtered and sorted according to the association strength of the multi-level relationships. Historical cost cases that meet the preset conditions are retained, and the cost entities are extracted according to the cost components to form the candidate cost reference set.

4. The method according to claim 3, characterized in that, Mapping the module name and module function attributes in the functional module identifier, as well as the functional entities of each historical cost case, into a vector space, and calculating the matching degree between the functional module identifier and the functional entities of each historical cost case based on the semantic distance in the vector space includes: Extract the module name and module function attribute from the functional module identifier and concatenate them to form a functional module description text. Extract the functional module name and function attribute value corresponding to the functional entity of each historical cost case from the software cost knowledge graph and concatenate them to form a historical function description text. The functional module description text is semantically encoded to obtain a functional module vector. The historical functional description text is semantically encoded to obtain a historical functional vector corresponding to each historical cost case. The functional module vector and each historical functional vector are mapped to a unified vector space. In the vector space, the vector distance between the functional module vector and each historical functional vector is calculated. The vector distance is converted into a semantic distance. Based on the semantic distance, the matching degree between the functional module identifier and the functional entity of each historical cost case is calculated. The matching degree is negatively correlated with the semantic distance.

5. The method according to claim 1, characterized in that, The similarity is fused based on the adjusted weights, and the candidate cost reference set is filtered and aggregated to generate a cost estimation benchmark value, including: The adjusted weights are combined with the initial similarity of the corresponding dimensions to obtain the comprehensive similarity of each historical cost case in the candidate cost reference set. The historical cost cases are then sorted in descending order based on the comprehensive similarity. A comprehensive similarity threshold is set, and historical cost cases with a comprehensive similarity higher than the comprehensive similarity threshold are selected from the sorted historical cost cases to form a high similarity case subset; The cost entities corresponding to the high-similarity case subset are extracted from the software cost knowledge graph. The actual cost values ​​in the cost entities are obtained. The similarity normalization coefficient is calculated based on the comprehensive similarity of each historical cost case. The actual cost values ​​and the corresponding similarity normalization coefficients are aggregated to obtain the cost estimation benchmark value.

6. The method according to claim 5, characterized in that, The cost estimation benchmark value is converted into a cost assessment result and presented to the user. Feedback and correction instructions from the user regarding the cost assessment result are received. Based on these feedback and correction instructions, sources of cost deviation are identified, including: Extract the cost components corresponding to the cost estimation benchmark value, obtain the cost item values ​​of each cost component, and combine the cost estimation benchmark value and the cost item values ​​to generate a cost assessment result that includes the total cost and the item costs. Receive feedback correction instructions from users regarding the cost assessment results, and parse the correction intent and correction object in the feedback correction instructions. The correction object includes the overall cost correction object and the itemized cost correction object. When the correction intention is a deviation tracing operation, the type of the correction object is determined. When the correction object is an overall cost correction object, the source of the cost deviation is located to the adjusted weight and the comprehensive similarity threshold. When the correction object is a sub-item cost correction object, the cost component entity corresponding to the sub-item cost correction object is extracted. The business complexity feature nodes and non-functional constraint nodes associated with the cost component entity in the software cost knowledge graph are queried. The source of the cost deviation is located to the feature extraction process corresponding to the business complexity feature nodes and the non-functional constraint nodes.

7. A software cost intelligent evaluation interactive system based on human-computer dialogue, used to implement the method as described in any one of claims 1-6, characterized in that, include: The first unit is used to obtain the user's software project description information, perform intent recognition and entity extraction on the software project description information, obtain functional module identifiers, business complexity characteristics and non-functional constraints, and construct a set of project requirement elements. The second unit is used to perform semantic matching between the set of project requirement elements and the pre-built software cost knowledge graph based on the functional module identifier, establish the association between the requirement elements and historical cost cases, and obtain a candidate cost reference set. The third unit is used to calculate the similarity of each dimension of each historical cost case in the candidate cost reference set based on the business complexity characteristics and the non-functional constraints. Based on the matching degree between the current project requirements and historical cases in each dimension, the weight of each dimension is adaptively adjusted. The similarity is fused based on the adjusted weights, and the candidate cost reference set is screened and aggregated to generate a cost estimation benchmark value. The fourth unit is used to convert the cost estimation benchmark value into a cost assessment result and present it to the user, receive feedback correction instructions from the user regarding the cost assessment result, identify the source of cost deviation based on the feedback correction instructions, map the source of cost deviation to an incremental update operation on the set of project requirement elements, execute the incremental update operation, and deliver the updated cost assessment result to the user.

8. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 6.

Images