A software development and management system for card production data processing based on artificial intelligence.

Abstract

This invention provides a card production data processing software development and management system based on artificial intelligence, including a requirements management module, a software project management module, a development assistance module, a test data and test case management module, and a full lifecycle management module. The development assistance module receives key points transmitted by the software project management module and uses LLM (Limited Language Management) for code generation, annotation, and segment labeling. Simultaneously, it dynamically updates the code knowledge base based on the code generation and optimization process through a built-in knowledge base self-iteration mechanism. The test data and test case management module generates large-scale test data and test cases based on small-batch card production data and accompanying documentation provided by the customer, using LLM and a dynamic card production data rule base, and executes an automated testing process. This invention can effectively improve the development efficiency of card production data processing software, increase software test coverage and effectiveness, reduce software maintenance and management costs, and mitigate the risks associated with purely manual development.

Description

Technical Field

[0001] This invention relates to the field of smart card data processing software technology, specifically to a card manufacturing data processing software development and management system based on artificial intelligence, aiming to improve the development efficiency, quality, and maintainability of card manufacturing data processing software by utilizing artificial intelligence technology. Background Technology

[0002] In financial card manufacturing order projects, card manufacturers need to process the raw data provided by banks and develop corresponding card manufacturing data processing software.

[0003] However, existing technologies have the following problems: 1. Lack of sufficient test samples: Clients often only provide a small amount of test data and accompanying explanations for card vendors to reference, resulting in low development efficiency and compromised software quality. For example, during the development of data processing technology projects, it is necessary to consider the organization of large amounts of data based on actual business needs, but a small amount of test data is insufficient to meet this requirement, significantly extending the development period of financial card data processing software.

[0004] 2. Increasingly complex business operations make it difficult to adapt to rapid iteration: Data processing is a crucial step in the production of financial smart cards, with short lead times and high quality requirements. Currently, most data processing software development relies on the experience of veteran employees, which is insufficient to meet the high-efficiency and high-quality business characteristics as customer needs become increasingly complex and personnel changes occur.

[0005] 3. Chaotic version management and difficulty in deployment and updates: Version conflicts and compatibility issues frequently occur in actual production. Faced with the need for rapid iteration, a lot of manpower is spent on dealing with software version management issues.

[0006] 4. Complex business needs are difficult to standardize: With changes in the international situation and domestic policies, the complexity of bank customer card issuance business is increasing. The current model of manually summarizing and sorting out customer needs is difficult to clearly express the true needs of customers. Summary of the Invention

[0007] To address the various shortcomings of existing technologies, this invention provides a card-making data processing software development and management system based on an artificial intelligence agent. By managing the card-making data processing software throughout its entire lifecycle through an artificial intelligence agent, the system effectively improves the development efficiency of the software, increases the coverage and effectiveness of software testing, promotes the standardization of requirements, reduces software maintenance and management costs, effectively improves the response speed to software requirements, and reduces the risks caused by purely manual development.

[0008] The present invention achieves the above objectives through the following technical solutions: A card-making data processing software development and management system based on artificial intelligence includes: The demand management module is used to receive, classify and manage card production data processing demands from customers. It uses a large language model (LLM) to compare and correlate the currently received customer demands with historical demand data to determine whether the demand type is a new demand or an upgrade demand for existing software. The software project management module performs corresponding operations based on the judgment results of the requirements management module. If it is a new requirement, it automatically creates a new software project and extracts and analyzes the key functional points. If it is an upgrade requirement, it associates the requirement with the requirements and project information of the previous version of the software and obtains the requirement upgrade points through the Large Language Model (LLM). The development auxiliary module receives key functional points or requirement upgrade points transmitted by the software project management module, and uses the Large Language Model (LLM) to generate, annotate, and mark code snippets; at the same time, it dynamically updates the code knowledge base based on the code generation and optimization process through a built-in knowledge base self-iteration mechanism. The test data and test case management module generates large batches of test data and test cases based on the small batch card production data and its documentation provided by the customer, using the Large Language Model (LLM) and dynamic card production data rule base, and executes the automated testing process. The full lifecycle management module runs through all stages of the card data processing software's lifecycle, including requirements analysis, design and development, system testing, deployment and implementation, and post-maintenance, to achieve full-process monitoring and management.

[0009] According to the card-making data processing software development and management system based on artificial intelligence provided by the present invention, when the key functional point is a requirement change point, the development auxiliary module is used to perform the following steps: The requirement change point serves as the trigger point for the entire development support process, initiating the development support process. Input the requirement change points into the Large Language Model (LLM) and use the Large Language Model (LLM) to generate code. The generated code is split, and performance probes are embedded in the split code through comparative analysis; Perform performance verification on the code after embedding performance probes; If the performance check fails, information related to the current code performance problem is retrieved from the code knowledge base, alternative solutions are recommended based on the retrieved information, and the performance check and related processes are re-executed. If the performance verification passes, the code that passes the performance verification and related information will be updated and stored in the code knowledge base to enrich the knowledge base content. The updated code knowledge base is stored in a structured case format to complete the entire development support process.

[0010] According to the card-making data processing software development and management system based on artificial intelligence agents provided by the present invention, during the construction of the Large Language Model (LLM): When constructing the original dataset, the historical project requirements are subjected to multi-granular semantic parsing, classified and labeled according to multiple requirement dimensions, and the labeled information is linked to the corresponding code segments to establish a multi-dimensional association index. This completes the process of constructing the original dataset by organizing the historical project requirements and corresponding code. Organize historical code optimization records into a structured knowledge base; Only the top-level parameters of the model are fine-tuned, and a low-rank matrix is ​​inserted before the output of each layer. For the low-rank matrix responsible for capturing task-specific input features, a dynamic weight allocation mechanism is adopted to dynamically adjust the attention weight of the matrix to different dimensions of the input features according to different structured data processing task scenarios. For the low-rank matrix responsible for generating task-adaptive output adjustments, a feedback optimization mechanism is introduced. Based on the model's output performance in practical applications, the parameters of the matrix are adjusted and optimized in real time to ensure that the generated output adjustments can continuously and effectively improve the model's performance on structured data processing tasks. In the adjusted large model structure, the LoRA module of the Transformer layer adopts an adaptive fusion strategy to fuse with the top-level parameters. Based on the complexity of the input data and the difficulty of the task, the fusion ratio of the LoRA module when fusing domain knowledge is automatically adjusted. When the task routing layer dynamically selects the output head based on the input content, it establishes a mapping model between the feature vector of the input content and the selection probability of the output head. Through learning and training on a large amount of historical input and output data, the mapping model can calculate the selection probability of each output head based on the feature vector of the input content.

[0011] According to the card-making data processing software development and management system based on artificial intelligence provided by the present invention, the knowledge base self-iteration mechanism includes a dynamic update module, which is used to perform the following operations: When capturing code changes and extracting new / optimized code snippets, incremental capture technology based on version control systems is used to locate the code changes involved in each commit in the code repository; The differential comparison algorithm is used to identify improvement points in the extracted code snippets, including at least the specific identification and annotation of code logic improvements, functional improvements, and code performance optimization points; In the confidence verification stage, a dynamic threshold for the number of evaluations is set for operations that undergo multiple random trial and error tests to assess stability. At the same time, based on the standard of small fluctuations in the judgment results, a multi-dimensional entropy calculation method is introduced to evaluate and analyze the code output results from different dimensions and calculate the multi-dimensional entropy value.

[0012] According to the card-making data processing software development and management system based on artificial intelligence provided by the present invention, the knowledge base self-iteration mechanism includes a knowledge application module, which is used to perform the following operations: When performing structured storage operations on historical optimization cases, they are classified and stored according to multiple classification dimensions, and a multi-dimensional index system is established. A corresponding multi-dimensional index label is generated for each historical optimization case. Through these index labels, it is ensured that the large language model LLM can efficiently retrieve the required information when generating code. When the Large Language Model (LLM) performs code generation tasks, it extracts key feature information of the current code generation task based on a similarity matching intelligent recommendation mechanism. Using a preset similarity calculation algorithm, it calculates the similarity between the current code generation task and historical optimization cases in the structured storage unit in multiple aspects. The historical optimization cases are sorted according to the similarity scores, and relevant historical optimization cases with high similarity are recommended to the LLM according to a preset recommendation quantity threshold. This allows the LLM to more effectively learn from historical experience and improve the quality and efficiency of generated code.

[0013] According to the card-making data processing software development and management system based on artificial intelligence agents provided by the present invention, the following steps are included in the process of executing the feedback closed loop: A layered embedding strategy is used to embed lightweight probes in the generated code. Different processing is performed according to different functional modules and importance of the code. Probes are encrypted and embedded in the key business logic layer, data processing layer and core code parts; the number of probes embedded in auxiliary and non-core code parts is reduced. Perform multi-dimensional analysis and visualization of the performance metrics data monitored in real time; When performance is detected to be substandard, an intelligent retrieval method based on performance problem characteristics is used to automatically trigger a knowledge base retrieval. Key features are extracted based on the specific performance problem detected, and a precise matching retrieval is performed in the knowledge base. Based on the complexity and scope of the performance issues, multiple alternatives of different levels and types are provided; at the same time, each recommended solution is described in detail and evaluated to form a closed-loop mechanism for continuous improvement.

[0014] According to the card-making data processing software development and management system based on artificial intelligence agents provided by the present invention, in the knowledge base self-iteration mechanism, the lightweight probe is a dynamic instrumentation module integrated into the target code, and its configuration is as follows: The system collects performance data non-intrusively during code execution, including the time consumed by a single function call, peak thread-level memory allocation, and resource usage trajectory during the object's lifecycle. The collected data is aggregated and analyzed in real time using a preset sliding window algorithm to generate a detection report that includes performance anomaly probability values ​​and anomaly type labels. When the anomaly probability value exceeds the threshold, the knowledge base retrieval module is automatically triggered, and the current code context, performance data, and anomaly tags are used as retrieval parameters to obtain a list of recommended optimization solutions that match the current execution environment.

[0015] According to the present invention, a card-making data processing software development and management system based on artificial intelligence agents includes a test data and test case management module comprising: Two-layer rule engine architecture: Basic rule layer: The card production data atomic rules adopt a modular storage method. Each atomic rule is independently encapsulated and equipped with a rule description document. At the same time, a unique identifier is set for each atomic rule so as to quickly call and accurately identify it when orchestrating the rule chain. Business portfolio layer: The rule chain orchestration adopts a visual interface operation; during the rule hot update process, a canary release mechanism is adopted to first verify the new card type rules in some test environments before promoting them; Intelligent data generation engine: When generating data based on the CSP solver, the data structure, business logic, and boundary conditions are prioritized. The weight of each constraint is dynamically adjusted according to different test scenarios and requirements to make the generated data more consistent with the actual business situation. When actively injecting abnormal data patterns during integrated mutation testing, an abnormal data pattern library is established to classify, store, and manage different types of abnormal data; based on the system's historical defect data and business characteristics, abnormal data patterns are intelligently selected for injection. Automated quality verification closed-loop process: When constructing the defect association graph of test data, a graph database is used for storage, with test data as nodes and defect types and repair solutions as edges, clearly showing the complex relationship between test data and defects; in addition, the defect association graph is updated in real time, and the graph content is updated in a timely manner whenever new test data triggers a defect or a defect is repaired. In this process, when the defect analysis results drive the rule base iteration through the rule base optimization and update node, a mapping relationship between the analysis results and the rule base is established. Based on the defect analysis results, the rules that need to be optimized are determined, and specific optimization schemes are formulated to achieve accurate iteration of the rule base and continuously improve the quality and reliability of test data and test case management modules.

[0016] According to the card data processing software development and management system based on artificial intelligence provided by the present invention, a unified demand receiving interface is established in the demand management module to support various forms of customer demand input. The preprocessed current customer demand text is input into the large language model LLM, and the data in the historical demand database is provided to the large language model LLM as reference corpus. Leveraging the natural language understanding and semantic analysis capabilities of the Large Language Model (LLM), keywords, key phrases, and semantic features of current customer needs are extracted to generate a vector representation of current needs. Based on the preset similarity calculation algorithm, the current demand vector is compared with each demand vector in the historical demand database one by one, and the similarity score between them is calculated. Set a similarity threshold. When the similarity score between the current customer's needs and a certain historical needs is higher than the threshold, the current customer's needs are determined to be upgrade needs for existing software. When the similarity score between the current customer demand and all historical demands is lower than the set threshold, the current customer demand is determined to be a completely new demand. The results of the requirement type determination and related historical requirement information are organized and encapsulated, and output to the requirement management interface. At the same time, the determination results are recorded in the requirement management log.

[0017] According to the card data processing software development and management system based on artificial intelligence provided by the present invention, a data transmission channel is established between the software project management module and the requirements management module. The judgment result of the requirements management module on the customer's requirements type is obtained in real time through the channel. When the requirements management module determines that it is a new requirement, the software project management module automatically triggers the new project creation process, generates a new project record in the preset project management database, and assigns a unique project number to the project. The text description of the new requirement is input into the Large Language Model (LLM). The LLM uses its natural language processing capabilities to perform semantic analysis and understanding of the new requirement. Based on the function point recognition rules and the knowledge learned during model training, the LLM extracts key function points from the requirement text. Organize and classify the extracted key functional points, group them according to business logic or functional modules, and generate a list of key functional points. When the requirements management module determines that it is an upgrade requirement, the software project management module searches the requirements and project information database of the previous version of the software using the association information provided by the requirements management module; based on the key features involved in the upgrade requirement, it finds the corresponding requirements and project records of the previous version of the software and establishes the relationship between them; The text description of the upgrade requirement and the associated text of the previous version's software requirements are input into the Large Language Model (LLM). The LLM compares and analyzes the two requirement texts to identify the points of change in the upgrade requirement relative to the previous version's requirements, i.e., the requirement upgrade points.

[0018] Therefore, compared with the existing technology, the card data processing software development and management system based on artificial intelligence proposed in this invention has the following beneficial effects: 1. Based on a multimodal large language model and a software requirements and code knowledge base in the field of smart cards, this invention can automatically compare changes in business requirements. The system can quickly and accurately identify the points of requirement change and automatically generate matching software upgrade content and detailed code suggestions based on the rich historical experience and code patterns in the knowledge base. This achieves automation and intelligence, greatly shortens the time cycle from requirements analysis to software upgrade solution determination, and qualitatively improves business response speed.

[0019] 2. In the process of developing data processing software, this invention integrates a large language model for code generation, code annotation, and code snippet labeling. Based on the code snippets, iterative updates to the knowledge base ensure that the knowledge base is always synchronized with and up-to-date with the actual development situation. The knowledge base can promptly include new code patterns, best practices, and solutions. Through this dynamic accumulation and inheritance of knowledge, the data processing software developed within the pattern can cover all business needs, avoiding software incompleteness or defects caused by knowledge lag or lack, and effectively improving the quality and reliability of the software.

[0020] 3. This invention forms a card production data rule base based on the corresponding card production data specifications, and uses this rule base to generate batch card production test data with a specific organizational structure that meets the requirements of test cases. This fully covers various business scenarios and data combinations, ensuring that the software can operate normally under various complex conditions. Compared with traditional test data generation methods, the test data generated by this invention is more targeted and comprehensive, and can more effectively discover potential defects and problems in the software, thereby reducing the software defect rate, improving the stability and robustness of the software, and providing users with a better user experience.

[0021] 4. The system method of this invention comprehensively covers the entire lifecycle of data processing software, including requirements, development, testing, deployment, and maintenance. In the requirements phase, by automatically comparing and analyzing business requirements, it provides clear and accurate guidance for subsequent development work, avoiding rework and resource waste caused by unclear or frequently changing requirements. In the development phase, with the assistance of a large language model and the support of a knowledge base, developers can complete code writing and function implementation more efficiently, reducing communication costs and error rates during development. In the testing phase, the accurate test data generated by the dynamic card-making data rule base can improve testing efficiency and test coverage, shortening the testing cycle. In the deployment phase, the system can provide automated deployment schemes and configuration management, ensuring that the software can be deployed quickly and stably to the target environment. In the maintenance phase, the continuous iterative updates of the knowledge base and the system's automated monitoring functions can promptly identify and resolve problems that occur during software operation, reducing the difficulty and workload of maintenance work. Through intelligent management throughout the entire lifecycle, this invention achieves standardization, automation, and intelligence in software development and management, effectively reducing labor costs and improving the overall operational efficiency and economic benefits of enterprises.

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

[0023] Figure 1 This is a schematic diagram of an embodiment of a card-making data processing software development and management system based on artificial intelligence.

[0024] Figure 2 This is a schematic diagram of the system modules and operation flow in an embodiment of the card data processing software development and management system based on artificial intelligence of the present invention.

[0025] Figure 3 This is a flowchart illustrating the development assistance module in an embodiment of the card data processing software development and management system based on artificial intelligence of the present invention.

[0026] Figure 4 This is a functional flowchart of the test data and test case management module in an embodiment of the card data processing software development and management system based on artificial intelligence of the present invention. Detailed Implementation

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

[0028] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0029] An Example of a Card-Making Data Processing Software Development and Management System Based on Artificial Intelligence See Figure 1 This embodiment provides a card-making data processing software development and management system based on artificial intelligence, including: The demand management module is used to receive, classify and manage card production data processing demands from customers. It uses a large language model (LLM) to compare and correlate the currently received customer demands with historical demand data to determine whether the demand type is a new demand or an upgrade demand for existing software. The software project management module performs corresponding operations based on the judgment results of the requirements management module. If it is a new requirement, it automatically creates a new software project and extracts and analyzes the key functional points. If it is an upgrade requirement, it associates the requirement with the requirements and project information of the previous version of the software and obtains the requirement upgrade points through the Large Language Model (LLM). The development auxiliary module receives key functional points or requirement upgrade points transmitted by the software project management module, and uses the Large Language Model (LLM) to generate, annotate, and mark code snippets; at the same time, it dynamically updates the code knowledge base based on the code generation and optimization process through a built-in knowledge base self-iteration mechanism. The test data and test case management module generates large batches of test data and test cases based on the small batch card production data and its documentation provided by the customer, using a large language model (LLM) and a dynamic card production data rule base, and executes an automated testing process. The full lifecycle management module runs through all stages of the card data processing software's lifecycle, including requirements analysis, design and development, system testing, deployment and implementation, and post-maintenance, to achieve full-process monitoring and management.

[0030] In this embodiment, the system is implemented based on the interaction between an artificial intelligence agent and different system module interfaces, which shortens the development cycle of the card data processing software and reduces subsequent maintenance manpower costs and software defect risks. The general flowchart of the system modules and operation is as follows. Figure 2 As shown.

[0031] Upon receiving customer requirements, the requirements management module receives and categorizes them. Using LLM (Local Management Model) assistance, it compares and correlates these requirements with the most relevant requirements within the requirements management module to determine whether the customer's requirements are entirely new or upgrade requirements. If they are new requirements, a new software project is created in the software project management module, and the key functional points of the requirements are extracted, analyzed, and input into the development assistance module. If they are upgrade requirements, they are correlated with the previous version's software requirements and software project, and the upgrade points are extracted and analyzed using LLM assistance before being input into the development assistance module.

[0032] After receiving upgrade points and functionalities, the development support module generates code. The generated functionalities and related components are then reviewed, tested, and finally integrated by software development engineers. The successful integration is then returned to the software functional knowledge base for LLM (Low-Level Management) iteration. Software engineering engineers then proceed to the next step of automated testing for the integrated software.

[0033] The small-batch card production data and specifications provided by the customer are input into the test data and test case management module. With the assistance of LLM and by reading the knowledge base, large-batch test data is generated, and test cases required for the relevant functionalities are output. Automated testing is then performed based on the LLM. Software iterations and upgrades are then carried out based on the test results (logs, reports, etc.).

[0034] In this embodiment, as Figure 3 As shown, when a critical functional point is a requirement change point, the development support module is used to perform the following steps: The requirement change point serves as the trigger point for the entire development support process, initiating the development support process. Input the requirement change points into the Large Language Model (LLM) and use the Large Language Model (LLM) to generate code. The generated code is split, and performance probes are embedded in the split code through comparative analysis; Perform performance verification on the code after embedding performance probes; If the performance check fails, information related to the current code performance problem is retrieved from the code knowledge base, alternative solutions are recommended based on the retrieved information, and the performance check and related processes are re-executed. If the performance verification passes, the code that passes the performance verification and related information will be updated and stored in the code knowledge base to enrich the knowledge base content. The updated code knowledge base is stored in a structured case format to complete the entire development support process.

[0035] During the construction of a large language model (LLM): When constructing the original dataset, the historical project requirements are subjected to multi-granular semantic parsing, classified and labeled according to multiple requirement dimensions, and the labeled information is linked to the corresponding code segments to establish a multi-dimensional association index. This completes the process of constructing the original dataset by organizing the historical project requirements and corresponding code. Organize historical code optimization records into a structured knowledge base; Only the top-level parameters of the model are fine-tuned, and a low-rank matrix is ​​inserted before the output of each layer. For the low-rank matrix responsible for capturing task-specific input features, a dynamic weight allocation mechanism is adopted to dynamically adjust the attention weight of the matrix to different dimensions of the input features according to different structured data processing task scenarios. For the low-rank matrix responsible for generating task-adaptive output adjustments, a feedback optimization mechanism is introduced. Based on the model's output performance in practical applications, the parameters of the matrix are adjusted and optimized in real time to ensure that the generated output adjustments can continuously and effectively improve the model's performance on structured data processing tasks. In the adjusted large model structure, the LoRA module of the Transformer layer adopts an adaptive fusion strategy to fuse with the top-level parameters. Based on the complexity of the input data and the difficulty of the task, the fusion ratio of the LoRA module when fusing domain knowledge is automatically adjusted. When the task routing layer dynamically selects the output head based on the input content, it establishes a mapping model between the feature vector of the input content and the selection probability of the output head. Through learning and training on a large amount of historical input and output data, the mapping model can calculate the selection probability of each output head based on the feature vector of the input content.

[0036] Specifically, the system constructs an original dataset by organizing historical project requirements and corresponding code. Simultaneously, it organizes historical code optimization records (such as code before and after modifications, performance improvement data) into a structured knowledge base to facilitate subsequent model learning. Most parameters are frozen, retaining the underlying parameters of the pre-trained model, which are responsible for basic text understanding, logical reasoning, and other general capabilities. Only the top-level parameters of the model are fine-tuned. Specifically, two low-rank matrices are inserted before the output of each layer. One matrix captures task-specific input features, and the other generates task-adaptive output adjustments. Together, these "small patches" allow the large model to quickly master professional capabilities such as structured data processing while retaining its original general language understanding capabilities. The adjusted large model structure consists of: an input layer, embeddings, a Transformer layer (including a LoRA module), a task routing layer, and multiple output heads. The Transformer layer retains the underlying parameters and inserts a LoRA module at the top level to integrate domain knowledge. The task routing layer dynamically selects output heads (generating, interpreting, or suggesting) based on the input content (such as code type and performance requirements).

[0037] In this embodiment, the knowledge base self-iteration mechanism includes a dynamic update module, which is used to perform the following operations: When capturing code changes and extracting new / optimized code snippets, incremental capture technology based on version control systems is used to locate the code changes involved in each commit in the code repository; The differential comparison algorithm is used to identify improvement points in the extracted code snippets, including at least the specific identification and annotation of code logic improvements, functional improvements, and code performance optimization points; In the confidence verification stage, a dynamic threshold for the number of evaluations is set for operations that undergo multiple random trial and error tests to assess stability. At the same time, based on the standard of small fluctuations in the judgment results, a multi-dimensional entropy calculation method is introduced to evaluate and analyze the code output results from different dimensions and calculate the multi-dimensional entropy value.

[0038] In this embodiment, the knowledge base self-iteration mechanism also includes a knowledge application module, which is used to perform the following operations: When performing structured storage operations on historical optimization cases, they are classified and stored according to multiple classification dimensions, and a multi-dimensional index system is established. A corresponding multi-dimensional index label is generated for each historical optimization case. Through these index labels, it is ensured that the large language model LLM can efficiently retrieve the required information when generating code. When the Large Language Model (LLM) performs code generation tasks, it extracts key feature information of the current code generation task based on a similarity matching intelligent recommendation mechanism. Using a preset similarity calculation algorithm, it calculates the similarity between the current code generation task and historical optimization cases in the structured storage unit in multiple aspects. The historical optimization cases are sorted according to the similarity scores, and relevant historical optimization cases with high similarity are recommended to the LLM according to a preset recommendation quantity threshold. This allows the LLM to more effectively learn from historical experience and improve the quality and efficiency of generated code.

[0039] As can be seen, the knowledge base self-iteration mechanism in this embodiment mainly includes two core functional modules: dynamic updating and knowledge application. Regarding dynamic updating, code changes are captured, and newly added / optimized code snippets are extracted. A differential comparison algorithm is used to identify improvement points, which are then automatically updated to the knowledge base after confidence verification. Specifically, the confidence verification process evaluates the stability of the model-generated code through multiple random "trial and error" (Monte Carlo Dropout) tests. If the results show little fluctuation (low entropy), the code is used directly; otherwise, it is marked for review. Regarding knowledge application, historical optimization cases are structured and stored for priority reference by the LLM when generating code.

[0040] The process of executing a feedback loop includes the following steps: A layered embedding strategy is used to embed lightweight probes in the generated code. Different processing is performed according to different functional modules and importance of the code. Probes are encrypted and embedded in the key business logic layer, data processing layer and core code parts; the number of probes embedded in auxiliary and non-core code parts is reduced. Perform multi-dimensional analysis and visualization of the performance metrics data monitored in real time; When performance is detected to be substandard, an intelligent retrieval method based on performance problem characteristics is used to automatically trigger a knowledge base retrieval. Key features are extracted based on the specific performance problem detected, and a precise matching retrieval is performed in the knowledge base. Based on the complexity and scope of the performance issues, multiple alternatives of different levels and types are provided; at the same time, each recommended solution is described in detail and evaluated to form a closed-loop mechanism for continuous improvement.

[0041] Furthermore, in the knowledge base self-iteration mechanism, the lightweight probe is a dynamic instrumentation module integrated into the target code, configured as follows: The system collects performance data non-intrusively during code execution, including the time consumed by a single function call, peak thread-level memory allocation, and resource usage trajectory during the object's lifecycle. The collected data is aggregated and analyzed in real time using a preset sliding window algorithm to generate a detection report that includes performance anomaly probability values ​​and anomaly type labels. When the anomaly probability value exceeds the threshold, the knowledge base retrieval module is automatically triggered, and the current code context, performance data, and anomaly tags are used as retrieval parameters to obtain a list of recommended optimization solutions that match the current execution environment.

[0042] As can be seen, the execution feedback loop in this embodiment achieves code optimization through performance monitoring and adaptive tuning: a lightweight probe is embedded in the generated code to monitor performance indicators such as execution time and memory usage in real time. If performance is detected as substandard, a knowledge base search is automatically triggered to recommend alternative solutions, forming a closed-loop mechanism for continuous improvement.

[0043] In this embodiment, as Figure 4 As shown, the functions of the test data and test case management module include: Two-layer rule engine architecture: Basic rule layer: Card production data atomic rules (such as card number verification algorithm and validity period generation logic) adopt a modular storage method. Each atomic rule is independently encapsulated and equipped with a rule description document. At the same time, a unique identifier is set for each atomic rule so as to be quickly called and accurately identified during rule chain orchestration. Business portfolio layer: Supports complex organizational structure mapping through orchestratable rule chains and supports hot rule updates: New card type rules take effect within minutes through version management; rule chain orchestration adopts a visual interface operation; during the hot rule update process, a canary release mechanism is adopted to first verify the new card type rules in some test environments before promoting them. Intelligent data generation engine: When generating data based on the CSP solver, the data structure, business logic, and boundary conditions constraints are prioritized. The weight of each constraint is dynamically adjusted according to different test scenarios and requirements, so that the generated data is more in line with the actual business situation. It can be seen that the data generated based on the CSP solver automatically matches the applicable rule combination to ensure that the generated data simultaneously meets the triple constraints of data structure, business logic, and boundary conditions.

[0044] When actively injecting abnormal data patterns during integrated mutation testing, an abnormal data pattern library is established to classify, store, and manage different types of abnormal data. Based on the system's historical defect data and business characteristics, abnormal data patterns are intelligently selected for injection. It is evident that actively injecting abnormal data patterns through integrated mutation testing verifies the system's robustness.

[0045] Automated quality verification closed-loop process: When constructing the defect association graph of test data, a graph database is used for storage, with test data as nodes and defect types and repair solutions as edges, clearly showing the complex relationship between test data and defects; in addition, the defect association graph is updated in real time, and the graph content is updated in a timely manner whenever new test data triggers a defect or a defect is repaired. In this process, when the defect analysis results drive the rule base iteration through the rule base optimization and update node, a mapping relationship between the analysis results and the rule base is established. Based on the defect analysis results, the rules that need to be optimized are determined, and specific optimization schemes are formulated to achieve accurate iteration of the rule base and continuously improve the quality and reliability of test data and test case management modules.

[0046] Furthermore, a unified requirement receiving interface is established in the requirement management module to support various forms of customer requirement input. The preprocessed current customer requirement text is input into the large language model LLM, while the data in the historical requirement database is provided to the large language model LLM as reference corpus. Leveraging the natural language understanding and semantic analysis capabilities of the Large Language Model (LLM), keywords, key phrases, and semantic features of current customer needs are extracted to generate a vector representation of current needs. Based on the preset similarity calculation algorithm, the current demand vector is compared with each demand vector in the historical demand database one by one, and the similarity score between them is calculated. Set a similarity threshold. When the similarity score between the current customer's needs and a certain historical needs is higher than the threshold, the current customer's needs are determined to be upgrade needs for existing software. When the similarity score between the current customer demand and all historical demands is lower than the set threshold, the current customer demand is determined to be a completely new demand. The results of the requirement type determination and related historical requirement information are organized and encapsulated, and output to the requirement management interface. At the same time, the determination results are recorded in the requirement management log.

[0047] Furthermore, in the software project management module, a data transmission channel is established with the requirements management module. Through this channel, the judgment results of the requirements management module on the customer's requirement type are obtained in real time. When the requirements management module determines that it is a new requirement, the software project management module automatically triggers the new project creation process, generates a new project record in the preset project management database, and assigns a unique project number to the project. The text description of the new requirement is input into the Large Language Model (LLM). The LLM uses its natural language processing capabilities to perform semantic analysis and understanding of the new requirement. Based on the function point recognition rules and the knowledge learned during model training, the LLM extracts key function points from the requirement text. Organize and classify the extracted key functional points, group them according to business logic or functional modules, and generate a list of key functional points. When the requirements management module determines that it is an upgrade requirement, the software project management module searches the requirements and project information database of the previous version of the software using the association information provided by the requirements management module; based on the key features involved in the upgrade requirement, it finds the corresponding requirements and project records of the previous version of the software and establishes the relationship between them; The text description of the upgrade requirement and the associated text of the previous version's software requirements are input into the Large Language Model (LLM). The LLM compares and analyzes the two requirement texts to identify the points of change in the upgrade requirement relative to the previous version's requirements, i.e., the requirement upgrade points.

[0048] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0049] The above embodiments are merely preferred embodiments of the present invention and should not be construed as limiting the scope of protection of the present invention. Any non-substantial changes and substitutions made by those skilled in the art based on the present invention shall fall within the scope of protection claimed by the present invention.

Claims

1. A card-making data processing software development and management system based on artificial intelligence, characterized in that, include: The demand management module is used to receive, classify and manage card production data processing demands from customers. It uses a large language model (LLM) to compare and correlate the currently received customer demands with historical demand data to determine whether the demand type is a new demand or an upgrade demand for existing software. The software project management module performs corresponding operations based on the judgment results of the requirements management module. If it is a new requirement, it automatically creates a new software project and extracts and analyzes the key functional points. If it is an upgrade requirement, it associates the requirement with the requirements and project information of the previous version of the software and obtains the requirement upgrade points through the Large Language Model (LLM). The development auxiliary module receives key functional points or requirement upgrade points transmitted by the software project management module, and uses the Large Language Model (LLM) to generate, annotate, and mark code snippets; at the same time, it dynamically updates the code knowledge base based on the code generation and optimization process through a built-in knowledge base self-iteration mechanism. The test data and test case management module generates large batches of test data and test cases based on the small batch card production data and its documentation provided by the customer, using the Large Language Model (LLM) and dynamic card production data rule base, and executes the automated testing process. The full lifecycle management module runs through all stages of the card data processing software's lifecycle, including requirements analysis, design and development, system testing, deployment and implementation, and post-maintenance, to achieve full-process monitoring and management. During the construction of a large language model (LLM): When constructing the original dataset, the historical project requirements are subjected to multi-granular semantic parsing, classified and labeled according to multiple requirement dimensions, and the labeled information is linked to the corresponding code segments to establish a multi-dimensional association index. This completes the process of constructing the original dataset by organizing the historical project requirements and corresponding code. Organize historical code optimization records into a structured knowledge base; Only the top-level parameters of the model are fine-tuned, and a low-rank matrix is ​​inserted before the output of each layer. For the low-rank matrix responsible for capturing task-specific input features, a dynamic weight allocation mechanism is adopted to dynamically adjust the attention weight of the matrix to different dimensions of the input features according to different structured data processing task scenarios. For the low-rank matrix responsible for generating task-adaptive output adjustments, a feedback optimization mechanism is introduced. Based on the model's output performance in practical applications, the parameters of the matrix are adjusted and optimized in real time to ensure that the generated output adjustments can continuously and effectively improve the model's performance on structured data processing tasks. In the adjusted large model structure, the LoRA module of the Transformer layer adopts an adaptive fusion strategy to fuse with the top-level parameters. Based on the complexity of the input data and the difficulty of the task, the fusion ratio of the LoRA module when fusing domain knowledge is automatically adjusted. When the task routing layer dynamically selects the output head based on the input content, it establishes a mapping model between the feature vector of the input content and the selection probability of the output head. Through learning and training on a large amount of historical input and output data, the mapping model can calculate the selection probability of each output head based on the feature vector of the input content.

2. The system according to claim 1, characterized in that, When a critical functional point is a requirement change point, the development support module is used to perform the following steps: The requirement change point serves as the trigger point for the entire development support process, initiating the development support process. Input the requirement change points into the Large Language Model (LLM) and use the Large Language Model (LLM) to generate code. The generated code is split, and performance probes are embedded in the split code through comparative analysis; Perform performance verification on the code after embedding performance probes; If the performance check fails, information related to the current code performance problem is retrieved from the code knowledge base, alternative solutions are recommended based on the retrieved information, and the performance check and related processes are re-executed. If the performance verification passes, the code that passes the performance verification and related information will be updated and stored in the code knowledge base to enrich the knowledge base content. The updated code knowledge base is stored in a structured case format to complete the entire development support process.

3. The system according to claim 1, characterized in that, The knowledge base self-iteration mechanism includes a dynamic update module, which is used to perform the following operations: When capturing code changes and extracting new / optimized code snippets, incremental capture technology based on version control systems is used to locate the code changes involved in each commit in the code repository; The differential comparison algorithm is used to identify improvement points in the extracted code snippets, including at least the specific identification and annotation of code logic improvements, functional improvements, and code performance optimization points; In the confidence verification stage, a dynamic threshold for the number of evaluations is set for operations that undergo multiple random trial and error tests to assess stability. At the same time, based on the standard of small fluctuations in the judgment results, a multi-dimensional entropy calculation method is introduced to evaluate and analyze the code output results from different dimensions and calculate the multi-dimensional entropy value.

4. The system according to claim 3, characterized in that, The knowledge base self-iteration mechanism includes a knowledge application module, which is used to perform the following operations: When performing structured storage operations on historical optimization cases, they are classified and stored according to multiple classification dimensions, and a multi-dimensional index system is established. A corresponding multi-dimensional index label is generated for each historical optimization case. Through these index labels, it is ensured that the large language model LLM can efficiently retrieve the required information when generating code. When the Large Language Model (LLM) performs code generation tasks, an intelligent recommendation mechanism based on similarity matching extracts key feature information of the current code generation task. Using a preset similarity calculation algorithm, it calculates the similarity between the current code generation task and historical optimization cases in the structured storage unit in multiple aspects. The historical optimization cases are ranked according to their similarity scores, and relevant historical optimization cases with high similarity are recommended to the LLM according to a preset recommendation quantity threshold. This allows the LLM to more effectively learn from historical experience and improve the quality and efficiency of generated code.

5. The system according to claim 1, characterized in that, The process of executing a feedback loop includes the following steps: A layered embedding strategy is used to embed lightweight probes in the generated code. Different processing is performed according to different functional modules and importance of the code. Probes are encrypted and embedded in the key business logic layer, data processing layer and core code parts; the number of probes embedded in auxiliary and non-core code parts is reduced. Perform multi-dimensional analysis and visualization of the performance metrics data monitored in real time; When performance is detected to be substandard, an intelligent retrieval method based on performance problem characteristics is used to automatically trigger a knowledge base retrieval. Key features are extracted based on the specific performance problem detected, and a precise matching retrieval is performed in the knowledge base. Based on the complexity and scope of the performance issues, multiple alternatives of different levels and types are provided; at the same time, each recommended solution is described in detail and evaluated to form a closed-loop mechanism for continuous improvement.

6. The system according to claim 5, characterized in that, In the knowledge base self-iteration mechanism, the lightweight probe is a dynamic instrumentation module integrated into the target code, and its configuration is as follows: The system collects performance data non-intrusively during code execution, including the time consumed by a single function call, peak thread-level memory allocation, and resource usage trajectory during the object's lifecycle. The collected data is aggregated and analyzed in real time using a preset sliding window algorithm to generate a detection report that includes performance anomaly probability values ​​and anomaly type labels. When the anomaly probability value exceeds the threshold, the knowledge base retrieval module is automatically triggered, and the current code context, performance data, and anomaly tags are used as retrieval parameters to obtain a list of recommended optimization solutions that match the current execution environment.

7. The system according to any one of claims 1 to 6, characterized in that, The test data and test case management module includes: Two-layer rule engine architecture: Basic rule layer: The card production data atomic rules adopt a modular storage method. Each atomic rule is independently encapsulated and equipped with a rule description document. At the same time, a unique identifier is set for each atomic rule so as to quickly call and accurately identify it when orchestrating the rule chain. Business portfolio layer: The rule chain orchestration adopts a visual interface operation; during the rule hot update process, a canary release mechanism is adopted to first verify the new card type rules in some test environments before promoting them; Intelligent data generation engine: When generating data based on the CSP solver, the data structure, business logic, and boundary conditions are prioritized. The weight of each constraint is dynamically adjusted according to different test scenarios and requirements to make the generated data more consistent with the actual business situation. When actively injecting abnormal data patterns during integrated mutation testing, an abnormal data pattern library is established to classify, store, and manage different types of abnormal data; based on the system's historical defect data and business characteristics, abnormal data patterns are intelligently selected for injection. Automated quality verification closed-loop process: When constructing the defect association graph of test data, a graph database is used for storage, with test data as nodes and defect types and repair solutions as edges, clearly showing the complex relationship between test data and defects; in addition, the defect association graph is updated in real time, and the graph content is updated in a timely manner whenever new test data triggers a defect or a defect is repaired. In this process, when the defect analysis results drive the rule base iteration through the rule base optimization and update node, a mapping relationship between the analysis results and the rule base is established. Based on the defect analysis results, the rules that need to be optimized are determined, and specific optimization schemes are formulated to achieve accurate iteration of the rule base and continuously improve the quality and reliability of test data and test case management modules.

8. The system according to any one of claims 1 to 6, characterized in that: A unified requirement receiving interface is established in the requirement management module to support various forms of customer requirement input. The preprocessed current customer requirement text is input into the large language model LLM, and the data in the historical requirement database is provided to the large language model LLM as reference corpus. Leveraging the natural language understanding and semantic analysis capabilities of the Large Language Model (LLM), keywords, key phrases, and semantic features of current customer needs are extracted to generate a vector representation of current needs. Based on the preset similarity calculation algorithm, the current demand vector is compared with each demand vector in the historical demand database one by one, and the similarity score between them is calculated. Set a similarity threshold. When the similarity score between the current customer's needs and a certain historical needs is higher than the threshold, the current customer's needs are determined to be upgrade needs for existing software. When the similarity score between the current customer demand and all historical demands is lower than the set threshold, the current customer demand is determined to be a completely new demand. The results of the requirement type determination and related historical requirement information are organized and encapsulated, and output to the requirement management interface. At the same time, the determination results are recorded in the requirement management log.

9. The system according to any one of claims 1 to 6, characterized in that: In the software project management module, a data transmission channel is established with the requirements management module. Through this channel, the judgment results of the requirements management module on the customer's requirement type are obtained in real time. When the requirements management module determines that it is a new requirement, the software project management module automatically triggers the new project creation process, generates a new project record in the preset project management database, and assigns a unique project number to the project. The text description of the new requirement is input into the Large Language Model (LLM), and the natural language processing capabilities of the LLM are used to perform semantic analysis and understanding of the new requirement. Large Language Model (LLM) extracts key functional points from requirement texts based on functional point recognition rules and knowledge learned during model training. Organize and classify the extracted key functional points, group them according to business logic or functional modules, and generate a list of key functional points. When the requirements management module determines that it is an upgrade requirement, the software project management module searches the requirements and project information database of the previous version of the software using the association information provided by the requirements management module; based on the key features involved in the upgrade requirement, it finds the corresponding requirements and project records of the previous version of the software and establishes the relationship between them; The text description of the upgrade requirement and the associated text of the previous version's software requirements are input into the Large Language Model (LLM). The LLM compares and analyzes the two requirement texts to identify the points of change in the upgrade requirement relative to the previous version's requirements, i.e., the requirement upgrade points.

Images