Intelligent demand analysis and work time evaluation method and system

Abstract

The application discloses a kind of intelligent demand analysis and man-hour evaluation method and system, belong to computer vision and artificial intelligence technical field, method includes: constructing multidimensional knowledge base;The multi-modal demand document containing text, picture and table is parsed, and structured demand data is generated;Based on structured demand data and system module description, module level split is carried out to demand, and module task set is generated;Based on multidimensional knowledge base, for each task in the module task set, retrieve associated system implementation context;Fusion structured demand data, module task set and system implementation context, generate fine-grained technical task;Based on historical case index, calculate benchmark man-hour for the fine-grained technical task;Baseline man-hour is successively carried out cross-module collaboration correction and personalized correction based on task performer ability, obtain final evaluation man-hour, can realize the automatic depth analysis and accurate, personalized man-hour evaluation of software demand.

Description

Technical Field

[0001] This invention relates to the fields of computer vision and artificial intelligence, and in particular to an intelligent demand analysis and working time assessment method and system. Background Technology

[0002] In the software development lifecycle, requirements analysis and time assessment are core components of the project planning phase, and their accuracy directly impacts project schedule, cost, and final delivery quality. Requirements typically exist in the form of multimodal documents, which not only contain extensive text descriptions but also interspersed with rich images, such as business process diagrams, system architecture diagrams, and user interface prototypes. This visual information carries crucial logical and design requirements.

[0003] Chinese Patent Publication No. CN118172031A discloses an artificial intelligence-based method, device, and medium for project management time assessment, addressing the problems of existing assessment methods involving numerous data sources, complex data processing, and low accuracy and efficiency. The method includes: collecting and labeling multi-dimensional project data from multiple data sources in project management, and expanding the project management sample data with new project samples based on the SMOTE algorithm using distance metric learning; extracting features from the multi-dimensional project data and the new project sample data using a feature extraction neural network and determining the probabilistic relationships between features; performing feature dimensionality reduction on the project management data based on the probabilistic relationships between features using an autoencoder neural network, and optimizing the selection of support vectors using a support vector machine algorithm based on decision boundary points to train a classifier; classifying the dimensionality-reduced multi-dimensional project data and the new project sample data using the trained classifier, and assessing project management time based on the classified data.

[0004] Existing technical solutions are severely inadequate in parsing image information in documents, failing to automatically identify and understand processing steps, judgment logic, or interactive elements in interface layouts within flowcharts. This results in the loss or misunderstanding of a large amount of key requirement information during analysis. The requirement analysis and task decomposition process is highly subjective, lacking objective correlation with existing system code and database structure. The decomposed tasks may be disconnected from actual technical implementation, and the complexity of collaboration between tasks and the impact of individual executor ability differences on working hours are not effectively quantified, leading to large fluctuations and low accuracy in evaluation results. Summary of the Invention

[0005] To address the aforementioned issues, this invention provides an intelligent requirements analysis and time assessment method and system. By constructing a multi-dimensional knowledge base, deeply analyzing the image content in the requirements document through a visual model, and combining historical data to perform contextual task decomposition and multi-dimensional time correction, it is possible to achieve automated in-depth analysis of software requirements and accurate, personalized time assessment.

[0006] The above objectives can be achieved through the following approach: A method for intelligent demand analysis and time assessment includes: Construct a multidimensional knowledge base, which should include at least a code index, a database index, and a historical case index; Parse multimodal requirement documents containing text, images, and tables to generate structured requirement data; Based on structured requirement data and system module descriptions, the requirements are broken down into modules to generate a set of module tasks. Based on a multidimensional knowledge base, the associated system implementation context is retrieved for each task in the module task set; By integrating structured requirement data, module task sets, and system implementation context, fine-grained technical tasks are generated. Based on the historical case index, base hours are calculated for fine-grained technical tasks; The baseline working hours are then adjusted through cross-module collaboration and personalized adjustments based on the capabilities of the task performers to obtain the final evaluated working hours.

[0007] Optionally, parsing the multimodal requirement document includes: extracting text paragraphs from the document; identifying and extracting embedded images from the document and recording their location markers; and identifying tables in the document and converting them into structured data formats.

[0008] Optionally, after identifying and extracting the images embedded in the document, the method further includes: performing content analysis on the extracted images using a visual model to identify flowchart nodes, interface layouts, or text content, and then associating and integrating the analysis results with the text content.

[0009] Optionally, the module-level decomposition of requirements includes: determining the software modules involved in the requirements based on the system module description, and constraining and correcting the number of tasks in the decomposed modules by combining the typical number of tasks and the frequency of module participation in similar requirements in historical cases.

[0010] Optionally, the construction of the multidimensional knowledge base includes: constructing the code index by performing static analysis on the source code, the code index including the backend code index and the frontend page index; and constructing the database index by reading database metadata. The historical case index is constructed by extracting features and vectorizing historical work order data.

[0011] Optionally, the system implementation context associated with the retrieval includes: selectively performing vector similarity retrieval in the backend code index, frontend page index, database index, and historical case index according to the current task type, and filtering and aggregating the retrieval results based on module metadata.

[0012] Optionally, the calculation of baseline working hours based on the historical case index includes: retrieving similar historical cases in the historical case index according to the description of the fine-grained technical task; obtaining the actual total working hours of the similar historical cases and their working hour distribution ratio on different task types; and allocating the reference total working hours to the current fine-grained technical task according to the working hour distribution ratio to form the baseline working hours.

[0013] Optionally, the cross-module collaboration correction is achieved by applying an adjustment coefficient that increases non-linearly with the number of system modules involved in the fine-grained technical task.

[0014] Furthermore, when the task involves one module, the coefficient is 1.0; when it involves two modules, the coefficient is 1.1 to 1.2; when it involves three or more modules, the coefficient is selectively preset based on past data experience.

[0015] Optionally, the personalized adjustment based on the task executor's ability includes: determining a first adjustment factor based on the matching relationship between the executor's job level and the task complexity; determining a second adjustment factor based on the executor's familiarity with the task-related business modules; and multiplying the baseline working hours by the first adjustment factor and the second adjustment factor to obtain the adjusted working hours.

[0016] It also provides an intelligent demand analysis and work hour assessment system, including: The multidimensional knowledge base module is used to store and maintain code indexes, database indexes, and historical case indexes; The document parsing module is configured to parse multimodal requirement documents to generate structured requirement data. The task decomposition engine is configured to generate a set of module tasks based on the structured requirement data and system module descriptions, and to generate fine-grained technical tasks based on the context retrieved by the multidimensional knowledge base module retrieval system. The work time assessment module is configured to calculate the baseline work time based on the historical case index, and perform cross-module correction and personalized correction to obtain the final assessed work time.

[0017] Optionally, the multidimensional knowledge base module includes: Code indexing units are used to store code semantic vectors extracted based on static analysis of the source code; Database index units are used to store table structures and relation vectors obtained by reading database metadata; The historical case index unit is used to store work order features and work hour distribution vectors obtained by feature extraction and vectorization of historical work order data.

[0018] Optionally, the task decomposition engine includes: A coarse-grained splitting proxy unit, configured to perform the module-level splitting; The fine-grained agent unit is configured to retrieve context based on the multidimensional knowledge base module and generate the fine-grained technical task.

[0019] Compared with the prior art, the present invention has the following advantages: This invention utilizes visual models to actively identify and structure these visual elements, transforming the business logic and interaction design contained within them into machine-readable data, which is then integrated with text information to obtain a deeper understanding of the original requirements, laying a solid foundation for subsequent accurate task decomposition.

[0020] This invention constructs a multi-dimensional knowledge base containing code, a database, and historical cases, closely linking abstract requirement descriptions with the concrete implementation at the system's underlying level. During task decomposition, the system no longer relies on personal experience but instead refines the task based on real-world context retrieved from the knowledge base, and uses historical data to calibrate the decomposition granularity, ensuring the rationality, traceability, and consistency of task decomposition with the current system status.

[0021] The evaluation process of this invention begins with objective data from similar historical cases, then systematically quantifies the additional communication and integration costs brought about by cross-module collaboration, and also fully considers personalized factors such as the individual abilities and module familiarity of the task performers. This correction mechanism ensures that the final work time assessment is no longer a rough estimate from a single dimension, but a dynamic and accurate prediction that integrates the task itself, team collaboration, and personnel capabilities. Attached Figure Description

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

[0023] Figure 1 This is a flowchart illustrating the overall architecture and processing flow of the system of the present invention; Figure 2 This is a flowchart of the time assessment algorithm based on historical distribution of the present invention; Figure 3 This is a flowchart of the multimodal document parsing process of the present invention; Figure 4 This is a flowchart illustrating the construction of a multidimensional vector knowledge base during the preprocessing stage of this invention. Detailed Implementation

[0024] 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, 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.

[0025] Reference Figure 1 As shown, one embodiment of the present invention proposes an intelligent demand analysis and working time assessment method, including: Construct a multidimensional knowledge base, which should include at least a code index, a database index, and a historical case index; Parse multimodal requirement documents containing text, images, and tables to generate structured requirement data; Based on structured requirement data and system module descriptions, the requirements are broken down into modules to generate a set of module tasks. Based on a multidimensional knowledge base, the associated system implementation context is retrieved for each task in the module task set; By integrating structured requirement data, module task sets, and system implementation context, fine-grained technical tasks are generated. Based on the historical case index, base hours are calculated for fine-grained technical tasks; The baseline working hours are then adjusted through cross-module collaboration and personalized adjustments based on the capabilities of the task performers to obtain the final evaluated working hours.

[0026] Specifically, by integrating scattered, unstructured technical and process assets such as source code, database structures, and historical project experience into a unified and computable knowledge base, and on this basis, deeply analyzing requirement documents in various forms, including text, images, and tables, human-described requirements are transformed into machine-understandable structured data. This structured requirement is mapped to the macro-module level of the software. Then, using specific code, data tables, and similar historical implementation cases retrieved from the knowledge base as context, module-level tasks are further refined into specific technical execution units. The principle of time assessment is based on data-driven and multi-dimensional correction. A baseline value is calculated using the actual time of similar historical tasks as the foundation, and then complexity corrections reflecting team collaboration overhead and ability corrections reflecting individual differences are successively added, thus progressively approximating the actual working hours.

[0027] By automating the parsing of multimodal requirements documents, requirement deviations caused by inconsistencies or omissions in human interpretation are effectively reduced. Contextual retrieval and task decomposition based on a multidimensional knowledge base ensure that the breakdown of technical tasks closely reflects the actual system, making the task list more executable and complete. A time-based assessment model, grounded in historical data and incorporating factors such as collaboration complexity and personnel capabilities, makes the time-based assessment results more scientific, transparent, and traceable. This method transforms requirements analysis and time-based assessment from a vague process highly dependent on human experience into a standardized, data-driven, and self-optimizing intelligent decision-making process, thereby enhancing the reliability and predictability of project planning.

[0028] Optionally, parsing multimodal requirement documents includes: extracting text paragraphs from the document; identifying and extracting embedded images from the document and recording their location markers; and identifying tables in the document and converting them into structured data formats.

[0029] Specifically, refer to Figure 3 As shown, by calling the document processing program, different element types in the document can be accurately separated: continuous text paragraphs are extracted to preserve complete semantic descriptions; all embedded image objects are identified and extracted, and reference marks are inserted in their original positions to maintain the relationship between text and images; table structures are identified and their contents are converted into structured data formats that preserve row and column relationships, thereby achieving lossless decomposition and digitization of textual, visual and tabular information contained in the document.

[0030] It achieves deep structuring of traditional requirements documents, overcoming the limitations of simple text analysis in handling chart information. It ensures that subsequent analysis engines can obtain complete, undistorted input data that retains the original logical relationships (such as text-to-image correspondence and table structure), laying a solid data foundation for accurately understanding complex, graphically rich business requirements.

[0031] Optionally, after identifying and extracting the images embedded in the document, the method further includes: performing content analysis on the extracted images using a visual model to identify flowchart nodes, interface layouts, or text content, and then associating and integrating the analysis results with the text content.

[0032] Specifically, after basic image extraction, a pre-trained multimodal visual model is used to intelligently recognize and semantically understand the image content. The visual model can parse the nodes and logical flow of flowcharts and identify components and layouts in interface prototype diagrams, transforming this visual information into a structured text description. Subsequently, the system strongly correlates this text description with previously recorded original image location markers, achieving deep semantic fusion between visual content and the overall document text. The visual model can be based on the Vision Transformer (ViT) architecture or its variants. This model divides the input image into fixed-size image patches. Each image patch is converted into an embedding vector through linear projection, added to the positional encoding, and then input into the Transformer encoder. Through multi-layer self-attention computation, the model can establish global associations between image patches, thereby understanding the overall structure and semantic content of the image. For example, a visual encoder based on the ViT-Large architecture can be used, with an input image resolution of 224×224 pixels, divided into 16×16 image patches. The model is pre-trained on a large-scale multimodal dataset containing rich visual data such as charts, flowcharts, and interface screenshots, learning a joint representation of images and text. When applied to requirements document analysis, this model can perform the following tasks in an end-to-end manner: identify text regions in images and extract text content; identify interface elements and their layout relationships; parse nodes and flow directions in flowcharts; and semantically associate the identification results with the text descriptions in the document.

[0033] It bridges the semantic gap between visual information and text processing, enabling unstructured graphical content to be directly utilized by subsequent natural language processing models. It enhances the understanding of requirement documents containing key graphical descriptions such as business process design and user interfaces, allowing automated analysis to cover a more comprehensive range of requirement information dimensions and improving the accuracy and completeness of task breakdown.

[0034] Optionally, the module-level decomposition of requirements includes: determining the software modules involved in the requirements based on the system module description, and constraining and correcting the number of tasks in the decomposed modules by combining the typical number of tasks and the frequency of module participation in similar requirements in historical cases.

[0035] Specifically, after performing preliminary semantic matching to identify potentially involved software modules, this method does not directly adopt the results but instead introduces historical experience as constraints. The system retrieves similar requirement cases from history, analyzing the scope of modules spanned and the number of typical tasks generated when these cases were ultimately decomposed and implemented. Using these historical statistical patterns, the rationality of the current preliminary decomposition results is verified and adjusted, for example, to prevent simple requirements from being over-decomposed into too many modules.

[0036] Reference Figure 2As shown, the correction mechanism based on historical data introduces an empirical quality control approach to module partitioning, simulating the prudent judgment of a senior architect. This avoids unreasonable partitioning caused by ambiguity in requirement descriptions or simple semantic matching deviations, ensuring the stability and practicality of module-level partitioning and providing a reliable and calibrated macro-framework for subsequent, more refined task decomposition.

[0037] Optionally, building a multi-dimensional knowledge base includes: constructing a code index by performing static analysis on the source code, which includes a backend code index and a frontend page index; constructing a database index by reading database metadata; and constructing a historical case index by extracting features and vectorizing historical work order data.

[0038] Specifically, refer to Figure 4 As shown, the code index automatically extracts structured information such as application interface definitions and business entity relationships through static syntax analysis of the source code repository. The database index obtains precise table structures, field definitions, and constraint relationships by directly reading system table metadata from the database. The historical case index extracts task descriptions, actual working hours, and working hour distribution characteristics by cleaning and processing historical work order data from the project management system. After vectorization processing, these heterogeneous data are respectively formed into specialized indexes that can be efficiently semantically retrieved.

[0039] By automatically building indexes directly from raw data sources, the system can continuously acquire and internalize the most accurate and timely knowledge of the system's current status and project history. This constitutes a dynamically updated "digital twin" knowledge body specific to the target software system, providing a real, reliable, and rich source of context for all subsequent intelligent analysis. This is the core capability foundation that distinguishes it from general models and enables accurate assessment.

[0040] Optionally, the system implementation context for retrieval includes: selectively performing vector similarity retrieval in the backend code index, frontend page index, database index, and historical case index based on the current task type, and filtering and aggregating the retrieval results based on module metadata.

[0041] Specifically, the system defines a precise strategy for contextual retrieval within the knowledge base. Instead of indiscriminately querying all indexes, the system dynamically selects the most relevant subset of indexes based on the specific type of the task being analyzed. For example, backend development tasks primarily query code and database indexes. After performing vector similarity retrieval, the system further utilizes pre-stored business module metadata fields in the index entries to filter the initial results, retaining only content directly related to the business module of the current task. This achieves precise focusing and filtering of massive amounts of technical information. The cosine similarity method is preferred for similarity measurement. This method has a mature application foundation in vector retrieval tasks and can effectively measure the degree of similarity between vectors in a multidimensional feature space. Cosine similarity measures the directional similarity of two vectors by calculating the cosine of the angle between them. The formula is: ; in and These are the query vector and the candidate vectors in the index, respectively. The range of cosine similarity values ​​is... A higher value indicates a higher similarity. This method is particularly suitable for calculating the similarity of text and semantic vectors because it focuses on the direction of the vectors rather than their magnitude, thus reducing the influence of vector length on similarity judgment.

[0042] For code semantic vectors and historical case feature vectors, since these vectors are usually sparsely distributed in high-dimensional space and semantic similarity focuses more on directional consistency, cosine similarity is used; for features with a high degree of structure, such as database table structure vectors.

[0043] This task-type-based routing and metadata-based filtering mechanism improves the precision and efficiency of context retrieval, ensuring that the technical context recalled for each task is highly relevant and focused, eliminating interference from irrelevant modules or common code snippets, and enabling the generated technical tasks to closely fit the specific architecture and implementation of the existing system, thereby enhancing the direct operability and feasibility of the output results.

[0044] Optionally, calculating the baseline working hours based on the historical case index includes: retrieving similar historical cases from the historical case index according to the description of the fine-grained technical task; obtaining the actual total working hours of the similar historical cases and their working hour distribution ratios on different task types; and allocating the reference total working hours to the current fine-grained technical task according to the working hour distribution ratios to form the baseline working hours.

[0045] Specifically, the system first searches the historical case library for past cases most similar to the current overall requirements, obtaining the total actual working hours of these cases and the proportion of working hours in different work categories. Referring to this historical working hour distribution pattern from real projects, the typical total working hours of similar cases are proportionally allocated to the various fine-grained technical tasks of the current requirements, rather than making isolated, bottom-up estimates for each task.

[0046] It cleverly inherits and applies the experience in overall workload assessment from historical projects, including various implicit collaboration and debugging costs, to the assessment of new requirements. This avoids the accumulation of deviations that may arise from independently estimating sub-task hours, making the calculation of baseline hours more consistent with the collective experience and objective laws of project execution, and significantly improving the rationality and robustness of the initial hour estimation.

[0047] Optionally, cross-module collaboration correction is achieved by applying an adjustment factor that increases nonlinearly with the number of system modules involved in the fine-grained technical task.

[0048] Furthermore, when the task involves one module, the coefficient is 1.0; when it involves two modules, the coefficient is 1.1 to 1.2; when it involves three or more modules, the coefficient is selectively preset based on past data experience.

[0049] Specifically, after calculating the baseline man-hours, the system identifies and counts the number of different system business modules involved in all fine-grained technical tasks. Based on a preset, non-linearly growing function or mapping relationship, it applies a corresponding amplification factor to different numbers of modules. This factor aims to quantify the additional workload caused by interface alignment, joint testing, and cross-team communication between modules, and the factor value increases rapidly as the number of modules involved increases.

[0050] This mechanism, for the first time in an automated evaluation model, explicitly quantifies and compensates for the significant implicit collaboration costs in distributed system development. This allows the evaluation results to more accurately reflect the comprehensive investment required to complete a requirement involving multi-team collaboration within a microservices or modular architecture. It addresses the key issues in traditional evaluation methods where this cost is difficult to measure, often underestimated, or omitted, thus improving the model's adaptability to evaluating complex projects.

[0051] Optionally, personalized adjustments based on the executor's capabilities include: determining a first adjustment factor based on the matching relationship between the executor's job level and the task complexity; determining a second adjustment factor based on the executor's familiarity with the task-related business modules; and multiplying the baseline working hours by the first and second adjustment factors to obtain the adjusted working hours.

[0052] Specifically, after obtaining a baseline based on the task itself and cross-module adjustments, the system introduces a multi-dimensional capability profile of the plan executor. By matching the executor's job level and experience with the complexity of the current task, an adjustment factor reflecting capability suitability is obtained. Simultaneously, another adjustment factor is derived based on the executor's historical familiarity with the specific business module to which the task belongs. The final evaluation time will be generated by the combined effect of these factors.

[0053] This method enables assessment results to dynamically reflect differences in human resource capabilities, achieving true "personalized assessment." It quantifies the learning costs that novice employees may incur when facing complex tasks, and also demonstrates the efficiency advantages of experienced employees when handling familiar modules. This provides project managers with scientific personnel assignment decision support, helping to achieve optimal matching of tasks and resources, thereby improving the overall delivery efficiency of the team and the individual accuracy of assessment results.

[0054] It also provides an intelligent demand analysis and work hour assessment system, including: The multidimensional knowledge base module is used to store and maintain code indexes, database indexes, and historical case indexes; The document parsing module is configured to parse multimodal requirement documents to generate structured requirement data. The task decomposition engine is configured to generate a set of module tasks based on structured requirement data and system module descriptions, and to generate fine-grained technical tasks based on the context of a multi-dimensional knowledge base module retrieval system. The work time assessment module is configured to calculate baseline work time based on historical case indexes, and perform cross-module corrections and personalized corrections to obtain the final assessed work time.

[0055] Specifically, the system consists of four core functional modules: a multi-dimensional knowledge base module, serving as the system's memory center, responsible for storing and retrieving vectorized index data; a document parsing module, acting as the input interface, responsible for converting raw documents into structured data; a task decomposition engine, serving as the intelligent processing core, responsible for executing coarse-to-fine requirement decomposition; and a work time assessment module, acting as the output calculator, responsible for performing work time calculations based on historical data and various correction algorithms. These modules interact and collaborate through predefined interface protocols.

[0056] Optional, the multidimensional knowledge base module includes: Code indexing units are used to store code semantic vectors extracted based on static analysis of the source code; Database index units are used to store table structures and relation vectors obtained by reading database metadata; The historical case index unit is used to store work order features and work hour distribution vectors obtained by feature extraction and vectorization of historical work order data.

[0057] Specifically, this module is not a single storage unit, but consists of three specialized indexing units: the code indexing unit specifically stores semantic vectors extracted from static analysis of source code; the database indexing unit specifically stores structural vectors extracted from database metadata; and the historical case indexing unit specifically stores experience vectors extracted from historical work order feature engineering. Each unit is optimized for the characteristics of its data type to achieve efficient storage and retrieval.

[0058] This separate yet unified architectural design enables the knowledge base to manage and process different types of technical knowledge and experience data in a professional manner, ensuring the accuracy and efficiency of each data retrieval. At the same time, providing a unified service interface simplifies the calling logic of upper-layer modules.

[0059] Optionally, the task breakdown engine includes: Coarsely split agent units, configured to perform module-level splitting; The agent unit is finely split and configured to retrieve context based on the multidimensional knowledge base module and generate fine-grained technical tasks.

[0060] Specifically, the engine employs a two-tier processing architecture, with a coarse-grained decomposition proxy unit and a fine-grained decomposition proxy unit working together. The coarse-grained decomposition proxy unit is responsible for quickly scanning requirements and performing high-level business domain segmentation based on system module descriptions; its decision-making is lightweight and rapid. The fine-grained decomposition proxy unit, within the scope defined by the coarse-grained decomposition, deeply utilizes the detailed context provided by the multi-dimensional knowledge base to decompose and generate descriptions of specific technical implementations; its process is thorough and meticulous.

[0061] By simulating the cognitive process of experts analyzing complex problems—first identifying the direction, then delving into the details—this approach not only improves the overall efficiency and logical clarity of the decomposition process but also effectively controls computational costs and complexity. Coarse decomposition ensures the correctness of the macro-level direction, while fine decomposition guarantees the accuracy of the micro-level solutions. The combination of these two methods makes the task decomposition process both efficient and reliable, enhancing the interpretability and stability of the entire system.

[0062] To verify the feasibility of this invention in practice, this embodiment demonstrates the application of the intelligent requirements analysis and time assessment method and system in a specific software development scenario. The scenario is set as a large online retail platform planning to upgrade its core transaction system, adding a business requirement to "support users merging shopping carts from multiple sources and enjoying tiered discounts corresponding to the merged total." The system adopts a microservice architecture, mainly including modules such as a user center, product services, shopping cart services, a promotion engine, and order services.

[0063] Prior to project implementation, the R&D team had completed a two-week knowledge base initialization using the system of this invention. The system scanned the backend Java (Spring Boot framework) code and the frontend Vue3 project using static code analysis tools (such as the ANTLR parser), successfully identifying and indexing core classes such as CartController (mapping path / api / v1 / cart) and PromotionRuleServiceImpl, along with their method signatures. It extracted the complete field definitions and inheritance relationships of JPA entity classes such as CartItem (mapping table t_cart_item) and PromotionRule (mapping table t_promo_rule), constructing a code semantic vector index. Simultaneously, it accessed the platform's core MySQL and Redis databases via a JDBC connector, extracting structured metadata from the INFORMATION_SCHEMA, including field names, types, primary and foreign key constraints, and comments, which were also converted into vectors and stored in the database index. In addition, the system collected requirement orders marked as "completed" by the project team over the past three years through the Jira REST API. After data cleaning (removing invalid and duplicate records), the system extracted the title, description text, and the list of subtasks (such as "modify the CartService.addItem method", "add a field to the promo_rules table", etc.) for each order and their corresponding actual man-hours (accurate to the man-hour). The system calculated the man-hour distribution ratio of the four task types "backend development", "frontend development", "database change" and "test integration" in each case, formed a feature vector, and built a historical case index.

[0064] The product manager uploaded a document titled "Shopping Cart Merging and Tiered Discount Functionality Requirements Specification V2.1" to the system. This document was in DOCX format with mixed text and images. The document parsing module used the Apache POI library to parse it: First, it extracted all the functional description text, such as "Users can merge shopping cart items from different scenarios such as 'daily browsing' and 'event venues.' The system needs to calculate the total amount of the merged items and automatically calculate the optimal discount based on preset tiered rules (such as 20 off for purchases over 200, 60 off for purchases over 500)." Then, the module identified a Visio flowchart (800x600 pixels) and a Word table embedded in the document. The system extracts the flowchart image into PNG format, inserts a location marker [Figure_1] at the original description "The merging process is shown in the figure below," and calls an integrated multimodal visual understanding model (such as a ViT-L-based visual encoder) to analyze the flowchart. The model outputs a structured description text: "This flowchart contains 4 nodes: 1. The user triggers the 'merge shopping cart' operation; 2. The system calls the CartService.merge method to deduplicate by product ID and summarize the quantity; 3. The system calls the PromotionEngine.calculateDiscount method, inputting the total amount to be merged and the rule set; 4. The engine returns the optimal discount amount and updates the shopping cart display." Simultaneously, the system identifies the "tiered discount rule table" in the document. This table has 3 rows and 3 columns (header: discount threshold, discount amount, whether it is stacked), and accurately converts it into a JSON array format: [{"threshold": 200, "discount": 20, "stackable": false}, {"threshold": 500, "discount": 60, "stackable": false}, {"threshold": 1000, "discount": 150, "stackable": false}]. Ultimately, all parsed results are integrated into a single JSON object, which is then output as the structured data required.

[0065] The task decomposition engine then starts. Its internal coarse decomposition agent unit first reads the YAML configuration file describing the current system architecture. This file clearly defines the responsibility boundaries of microservice modules such as "cart-service", "promotion-service", and "product-service". Combining keywords in the structured requirement data (such as "merge shopping carts" and "tiered discounts"), the unit calculates semantic similarity and initially determines that the requirement is highly related to "cart-service" (similarity score 0.87) and "promotion-service" (similarity score 0.92). At the same time, the unit queries the historical case index and uses the vector of the current requirement text to perform an approximate nearest neighbor search to recall the top-5 similar historical cases. Analysis shows that these 5 cases ultimately involve an average of 2.2 modules and generate an average of 3.8 module-level tasks. Based on this historical pattern, the system corrects the initial decomposition results, constraining the number of module tasks in this decomposition to a reasonable range of 3 to 4, and finally outputs the following set of module tasks: 1. Shopping cart service module: Enhance shopping cart merging logic and total amount calculation. 2. Promotion Engine Module: Extends the promotion rules engine to support tiered discount calculations.

[0066] Next, the proxy unit performs a fine-grained decomposition based on context for each module task. For the shopping cart service module task, the system initiates queries to the backend code index and database index based on its "backend logic modification" type. The query vector is generated from the task description, and the most relevant entries returned include: the source code snippet of the mergeCarts method in the CartServiceImpl class (similarity 0.91), the schema definition of the t_cart_item table (similarity 0.88), and a task description involving modification of CartQueryService in a historical case of "shopping cart item grouping display" (similarity 0.79). The system uses the service: cart-service metadata tag inherent in the index entries to filter the results to ensure context relevance. By integrating these contexts with the flowchart parsing results in the requirements, the proxy unit generates two fine-grained technical tasks: a) [Backend] Add a method calculateMergedTotal(Map) to CartServiceImpl.<Long, Integer> itemQuantityMap) is used to merge items and call the pricing service to calculate the total amount. b) [Database] Add a source_scene field (VARCHAR(20)) to the t_cart_item table to identify the source of the items (e.g., 'browse', 'campaign').

[0067] For the promotion engine module task, the system performs a similar retrieval process: retrieving the `applyRules` method of `PromotionEngineImpl` from the code index, retrieving the `t_promo_rule` table structure from the database index, and retrieving the implementation logic for "multiple coupon stacking calculation" from historical cases. Combining the retrieved context and the structured rule table data in the requirements, a fine-grained task is generated: c) [Database] Add a `ladder_json` field (TEXT) to the `t_promo_rule` table to store the ladder rule array in JSON format. d) [Backend] Modify the `PromotionEngineImpl.applyRules` method, adding a branch for judging `ruleType='LADDER'`, parsing `ladder_json`, and implementing the `findBestLadderDiscount(BigDecimal totalAmount)` logic to match the optimal ladder.

[0068] After receiving the descriptions of all four fine-grained technical tasks (a, b, c, d), the time assessment module initiates the assessment process. The module first merges the descriptions of these four tasks into a single overall requirement representation vector and then searches the historical case index. The system retrieves three of the most similar historical cases: "Cross-store discount activity" (Case ID: JIRA-4521), "Member level discount system upgrade" (JIRA-4890), and "Shopping cart coupon merging calculation optimization" (JIRA-5213). The actual average total time for these three cases is 112 person-hours, with the average distribution as follows: backend development 52%, database changes 18%, frontend development 22%, and testing and integration 8%. Based on this distribution, the system allocates the reference total time of 112 person-hours proportionally: backend tasks (a and d) share approximately 58 person-hours, database tasks (b and c) share approximately 20 person-hours (the remaining percentages are temporarily reserved). Next, based on the complexity ratings of tasks a and d (a being "medium" and d being "high"), the 58 person-hours were fine-tuned, with task a receiving 25 person-hours and task d receiving 33 person-hours; database tasks b and c were both rated "low," each receiving 10 person-hours. The initial baseline total man-hours was 25 + 10 + 33 + 10 = 78 person-hours.

[0069] Subsequently, the system identified tasks a and b as belonging to the cart-service, and tasks c and d as belonging to the promotion-service, involving 2 modules. According to preset rules: the coefficient is 1.0 when there are 1 module, 1.15 when there are 2 modules, and 1.3 when there are more than 2 modules. A cross-module collaboration adjustment coefficient of 1.15 is applied. The adjusted intermediate man-hours are 78 × 1.15 = 89.7 person-hours.

[0070] Finally, personalized adjustments are made. Assume tasks a and b are planned to be assigned to Senior Engineer Wang (Employee ID: ENG-101), whose job level is P8. His historical average efficiency coefficient for handling cart-service module tasks is 0.95 (meaning 5% faster than estimated), and he has completed 15 tasks in this module in the past six months, with a module familiarity factor rating of 0.85. Tasks c and d are planned to be assigned to Intermediate Engineer Li (ENG-205), whose job level is P6. He has relatively less experience in the promotion-service module, having completed only 3 tasks, with an efficiency coefficient of 1.05 and a module familiarity factor rating of 1.15. The system calculates the capability factor based on the "Job Level - Task Complexity" matrix (P8 handles "Medium" complexity factor 0.9, P6 handles "High" complexity factor 1.1). For Wang's task (intermediate working hours proportionally allocated to 40.3 person-hours): Final working hours E_wang = 40.3 × 0.9 (ability) × 0.85 (familiarity) × 0.95 (efficiency) ≈ 29.3 person-hours. For Li's task (intermediate working hours proportionally allocated to 49.4 person-hours): Final working hours 49.4 × 1.1 (ability) × 1.15 (familiarity) × 1.05 (efficiency) ≈ 65.7 person-hours. The final estimated working hours for the requirement are 29.3 + 65.7 = 95 person-hours. The system automatically rounds up to 10 working days (based on 8 working hours per day) and notes in the evaluation report: "Involves the linkage of shopping cart and promotion services, requiring close attention to interface integration and data consistency testing risks."

[0071] As demonstrated in this embodiment, when faced with a new functional requirement involving complex business rules and cross-service interactions, the system of the present invention can automatically complete the entire process—from requirement understanding and contextual task breakdown to multi-dimensional quantitative evaluation integrating historical benchmarks, collaboration costs, and personnel efficiency—based on deep analysis of multimodal documents and precise retrieval of the system's private knowledge base. The entire process is data-driven, with clear steps and interpretable results, significantly improving the efficiency, objectivity, and accuracy of the requirements analysis phase, and providing a reliable basis for scientific decision-making in project management.

[0072] All equivalent changes and modifications made in accordance with the teachings of this invention are still within the scope of this invention. Those skilled in the art will readily conceive of other embodiments of this invention upon considering the specification and the disclosure of practical truth. This application is intended to cover any variations, uses, or adaptations of this invention that follow the general principles of this invention and include common knowledge or conventional techniques in the art not described herein.

Claims

1. A method for intelligent demand analysis and time assessment, characterized in that, include: Construct a multidimensional knowledge base, which should include at least a code index, a database index, and a historical case index; Parse multimodal requirement documents containing text, images, and tables to generate structured requirement data; The parsing of multimodal requirement documents containing text, images, and tables includes: extracting text paragraphs from the document; identifying and extracting embedded images from the document and recording their location markers; identifying tables in the document and converting them into structured data formats; After identifying and extracting the images embedded in the document, the method further includes: performing content analysis on the extracted images using a visual model to identify flowchart nodes, interface layouts, or text content, and then associating and integrating the analysis results with the text content. Based on structured requirement data and system module descriptions, the requirements are broken down into modules to generate a set of module tasks. The module-level decomposition of requirements includes: determining the software modules involved in the requirements based on the system module description, and constraining and correcting the number of tasks in the decomposed modules by combining the typical number of tasks and the frequency of module participation in similar requirements in historical cases. Based on a multidimensional knowledge base, the associated system implementation context is retrieved for each task in the module task set; By integrating structured requirement data, module task sets, and system implementation context, fine-grained technical tasks are generated. Based on the historical case index, base hours are calculated for fine-grained technical tasks; The baseline working hours are then adjusted through cross-module collaboration and individualized adjustments based on the task executor's capabilities to obtain the final evaluated working hours. The personalized adjustment based on the task executor's capabilities includes: determining a first adjustment factor based on the matching relationship between the executor's job level and the task complexity; determining a second adjustment factor based on the executor's familiarity with the task-related business modules; and multiplying the baseline working hours by the first adjustment factor and the second adjustment factor to obtain the adjusted working hours. The cross-module collaboration correction is achieved by applying an adjustment coefficient that increases non-linearly with the number of system modules involved in the fine-grained technical task. The construction of the multidimensional knowledge base includes: constructing the code index by performing static analysis on the source code, the code index including the backend code index and the frontend page index; constructing the database index by reading database metadata; and constructing the historical case index by extracting features and vectorizing historical work order data.

2. The intelligent demand analysis and working hour assessment method according to claim 1, characterized in that, The system implementation context associated with the retrieval includes: selectively performing vector similarity retrieval in the backend code index, frontend page index, database index, and historical case index according to the current task type, and filtering and aggregating the retrieval results based on module metadata.

3. The intelligent demand analysis and working hour assessment method according to claim 1, characterized in that, The calculation of baseline working hours based on the historical case index includes: retrieving similar historical cases from the historical case index according to the description of the fine-grained technical task; obtaining the actual total working hours of the similar historical cases and their working hour distribution ratios on different task types; and allocating the reference total working hours to the current fine-grained technical task according to the working hour distribution ratios to form the baseline working hours.

4. An intelligent demand analysis and working hour assessment system, characterized in that, include: The multidimensional knowledge base module is used to store and maintain code indexes, database indexes, and historical case indexes; The document parsing module is configured to parse multimodal requirement documents to generate structured requirement data. The task decomposition engine is configured to generate a set of module tasks based on the structured requirement data and system module descriptions, and to generate fine-grained technical tasks based on the context retrieved by the multidimensional knowledge base module retrieval system. The work time assessment module is configured to calculate the baseline work time based on the historical case index, and perform cross-module correction and personalized correction to obtain the final assessed work time.

5. The intelligent demand analysis and working hour assessment system according to claim 4, characterized in that, The multidimensional knowledge base module includes: Code indexing units are used to store code semantic vectors extracted based on static analysis of the source code; Database index units are used to store table structures and relation vectors obtained by reading database metadata; The historical case index unit is used to store work order features and work hour distribution vectors obtained by feature extraction and vectorization of historical work order data.

6. The intelligent demand analysis and working hour assessment system according to claim 4 or 5, characterized in that, The task breakdown engine includes: Coarsely split agent units, configured to perform module-level splitting; The fine-grained agent unit is configured to retrieve context based on the multidimensional knowledge base module and generate the fine-grained technical task.

Images