Intelligent Bug management method and platform based on AI large model

Abstract

The invention discloses an intelligent Bug management method and platform based on an AI large model. The method comprises the steps that structured error codes, unstructured log texts and development communication records are collected; standardized Bug features are obtained after preprocessing; semantic matching is performed based on a CodeBERT large model to generate a historical similar Bug case set, and a problem code segment is analyzed and positioned in combination with an AST abstract syntax tree; according to the project technology stack features, the historical similar Bug case set and the problem code segment, generating a repair scheme including code modification suggestions, automatically generated repair code snippets and implementation risk assessment; constructing and optimizing a triple knowledge graph; and finally, associating the standardized Bug features, the problem code segment, the repair scheme and the knowledge graph to obtain a Bug diagnosis result, and outputting the Bug diagnosis result. According to the method, intelligent positioning and accurate repairing of the Bug are achieved, the average Bug solving time is remarkably shortened, and meanwhile automatic precipitation of development experience is achieved through the continuously optimized knowledge graph.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer software engineering and artificial intelligence, and particularly relates to an intelligent Bug management method and platform based on an AI large model. BACKGROUND

[0002] In the software development process, Bug management is a key link to ensure product quality, but at present it mainly relies on manual experience and rule matching, and there are obvious efficiency and accuracy bottlenecks. Developers usually need to manually review code, logs and communication records to locate problems, which is time-consuming and laborious and is easily affected by subjective experience. Although the traditional rule engine can handle simple error types, it is often difficult to provide effective solutions when facing complex Bugs such as concurrency problems or framework compatibility errors, because its matching method based on fixed templates.

[0003] Although the mainstream Bug management tools are relatively mature in process management, they lack intelligent analysis capabilities. These tools cannot deeply analyze code logic or associate multi-source data such as version change records and error logs, resulting in a low reuse rate of historical Bug experience. In addition, solutions are usually scattered in documents, emails or personal notes, making it difficult to systematize accumulation and sharing, and leading to repeated troubleshooting and knowledge gaps when cross-team collaboration. Since it is currently difficult to achieve precise positioning, intelligent repair and knowledge deposition of Bug closed-loop management, an intelligent solution that integrates code understanding, semantic analysis and dynamic knowledge evolution is urgently needed. SUMMARY

[0004] In view of the above problems, the present application provides an intelligent Bug management method and platform based on an AI large model, which realizes intelligent positioning and precise repair of Bugs through multi-source data fusion, code semantic analysis and dynamic knowledge graph construction, and solves the problems of low efficiency, knowledge gaps and insufficient repair accuracy in traditional Bug management.

[0005] To achieve the above purpose, in a first aspect, the present application provides an intelligent Bug management method based on an AI large model, comprising:

[0006] According to a preset rule, multi-source Bug data is collected, and the multi-source Bug data includes structured error code, unstructured log text and development communication records;

[0007] The multi-source Bug data is preprocessed to obtain standardized Bug features, and the standardized Bug features include error descriptions with unified semantic representation, code context parsed by abstract syntax tree and associated version information;

[0008] The CodeBERT large model is used for semantic matching of the standardized Bug features, a set of historical similar Bug cases is generated, and the Bug triggering logic chain is analyzed based on an AST (Abstract Syntax Tree) to obtain a problem code segment.

[0009] A repair scheme is generated based on the project technology stack features, the set of historical similar Bug cases, and the problem code segment. The repair scheme includes code modification suggestions adapted to the technology stack, automatically generated repair code segments, and implementation risk assessment.

[0010] A triple knowledge graph is constructed according to the repair scheme, and the accuracy of the triple knowledge graph is optimized through reinforcement learning.

[0011] The Bug diagnosis result is obtained by associating the standardized Bug features, the problem code segment, the repair scheme, and the knowledge graph, and is output.

[0012] In some embodiments, the multi-source Bug data is preprocessed to obtain standardized Bug features, including:

[0013] The unstructured log text is cleaned by regular expressions to remove garbled characters and redundant characters to obtain error descriptions.

[0014] The error descriptions are semantically standardized by a BERT word vector model, and bug symptoms with the same meaning but different expressions are mapped to a unified semantic representation.

[0015] Element features are extracted from the structured error code using a code analysis tool. The element features include class names, function names, and call chain relationships.

[0016] The version change information in the development communication records is spatio-temporally aligned with the error code and the log text to establish a version association relationship.

[0017] The preprocessed unified semantic representation, element features, and version association relationship are fused to generate standardized Bug features including unified semantic error descriptions, code context features, and version association information.

[0018] In some embodiments, the CodeBERT large model is used for semantic matching of the standardized Bug features to generate a set of historical similar Bug cases, including:

[0019] The standardized Bug features are multi-dimensionally semantically encoded by the encoder layer of the CodeBERT large model to generate deep semantic vectors.

[0020] The cosine similarity between the deep semantic vectors and the historical standardized Bug feature vectors of each historical Bug case in the historical Bug database is calculated, and a dynamic similarity threshold is set. The dynamic similarity threshold is automatically adjusted according to the current multi-source Bug data distribution characteristics.

[0021] Based on the cosine similarity obtained by calculation one by one, the historical Bug cases exceeding the dynamic similarity threshold are screened out, denoted as candidate historical Bug cases;

[0022] The candidate historical Bug cases are sorted in descending order of cosine similarity, and the top pre-set number of candidate historical Bug cases with the highest cosine similarity are aggregated to generate a historical similar Bug case set.

[0023] In some embodiments, the Bug triggering logic chain is analyzed based on the AST abstract syntax tree to obtain the problem code segment, including:

[0024] The error code contained in the standardized Bug feature is parsed in syntax to construct a complete AST abstract syntax tree;

[0025] Starting from the root node of the AST abstract syntax tree, the syntax nodes associated with the uniform semantic representation of error description are marked by layer-by-layer traversal along the call chain relationship;

[0026] The marked syntax nodes and their directly associated context nodes are extracted to form a candidate problem code segment set;

[0027] Each code segment in the candidate problem code segment set is executed path simulated to filter out the code segment that actually triggers the uniform semantic error description, denoted as the problem code segment.

[0028] In some embodiments, in combination with the project technology stack features, the historical similar Bug case set and the problem code segment, a repair scheme is generated, including:

[0029] A technology stack adaptation layer is constructed based on the project technology stack features, and the technology stack adaptation layer is used to convert the repair scheme format into an expression form that meets the pre-set expression conditions;

[0030] From the historical similar Bug case set, the historical repair strategies associated with each candidate historical Bug case are extracted, and the association weight of each historical repair strategy and the current problem code segment is calculated through an attention mechanism;

[0031] The historical repair strategies are weighted and fused according to the association weight to generate a preliminary repair scheme, and the syntax compatibility of the preliminary repair scheme and the problem code segment is verified;

[0032] The preliminary repair scheme that passes the verification is input into the technology stack adaptation layer for format conversion, and the final repair scheme that meets the requirements of the current project technology stack is output.

[0033] In some embodiments, the historical repair strategies associated with each candidate historical bug case are extracted from the historical similar bug case set, and the association weights of each historical repair strategy and the current problem code segment are calculated through an attention mechanism, including:

[0034] The problem code segment is converted into a problem feature vector through a word embedding layer, and each historical repair strategy is converted into a corresponding historical strategy feature vector;

[0035] A multi-head attention network is constructed to calculate the cross-modal similarity between the problem feature vector and each historical strategy feature vector, generating an initial attention score;

[0036] The success rate of repair in the historical similar bug case set is introduced as prior knowledge to weight and correct the initial attention score, obtaining a normalized association weight;

[0037] According to the normalized association weight, the historical repair strategies exceeding the preset association threshold are selected as effective repair strategies, and the normalized association weight corresponding to the effective repair strategies is recorded as the association weight.

[0038] In some embodiments, according to the repair scheme, a triple knowledge graph is constructed, including:

[0039] Repair elements are extracted from the repair scheme, including error type, repair operation and code context;

[0040] The repair elements are used as entity nodes of the knowledge graph;

[0041] Based on the version association information in the standardized bug features, the version evolution relationship between each entity node is established to form the relationship edge of the knowledge graph;

[0042] The entity nodes and relationship edges are organized according to the triple structure of error type-repair operation-code context to generate an initial knowledge graph;

[0043] The initial knowledge graph is embedded and represented through a graph neural network to generate a dynamic knowledge graph with version perception ability, recorded as a triple knowledge graph.

[0044] In some embodiments, the accuracy of the triple knowledge graph is optimized through reinforcement learning, including:

[0045] A reinforcement learning environment containing problem code segment entities, repair scheme entities and technical stack features is constructed, and the embedded representation of the entity nodes of the triple knowledge graph is used as the state space;

[0046] A composite reward function containing version evolution consistency, code modification effectiveness and risk control compliance rate is generated based on the implementation result feedback of the repair scheme;

[0047] The prediction weight of the entity relationship in the triple knowledge graph is iteratively optimized through the policy network to automatically correct the accuracy.

[0048] In some embodiments, multi-source Bug data is collected according to preset rules, including:

[0049] Through the API interface, the submission records of the project code repository are monitored in real time, and the commit message containing the error repair description is extracted as the first data source;

[0050] The static analysis tool is configured to scan the code library, and the detected potential defects and associated code segments are taken as the second data source;

[0051] The first data source and the second data source are integrated to generate structured error codes;

[0052] The work order records in the project management system are parsed, and the Bug reports with the status marker "fixed" and their solutions are selected as the third data source;

[0053] The third data source is split into unstructured log text and development communication records;

[0054] The multi-source Bug data is generated.

[0055] In the second aspect, the present application also provides an intelligent Bug management platform based on AI large model, which is suitable for the method of the first aspect.

[0056] Unlike the prior art, the above technical solution provides an intelligent Bug management method and platform based on AI large model, which includes: collecting structured error codes, unstructured log text and development communication records; obtaining standardized Bug features after preprocessing; generating a set of historical similar Bug cases based on CodeBERT large model for semantic matching, and positioning the problem code segment by combining AST abstract syntax tree analysis; generating a repair scheme containing code modification suggestions, automatically generated repair code segments and implementation risk assessment according to the project technology stack characteristics, the set of historical similar Bug cases and the problem code segment; constructing and optimizing the triple knowledge graph; finally, associating the standardized Bug features, the problem code segment, the repair scheme and the knowledge graph to obtain Bug diagnosis results and output. The present application realizes intelligent positioning and accurate repair of Bug, significantly reduces the average Bug resolution time, and realizes automatic deposition of development experience through continuously optimized knowledge graph.

[0057] The above summary related to the invention is only a summary of the technical solutions of the present application. In order to enable those skilled in the art to more clearly understand the technical solutions of the present application, and then implement the same according to the contents recorded in the specification and drawings, and in order to enable the above and other purposes, characteristics and advantages of the present application to be more easily understood, the following will be described in combination with the specific embodiments of the present application and the accompanying drawings. BRIEF DESCRIPTION OF DRAWINGS

[0058] The accompanying drawings are only used to show the principles, implementation manners, applications, characteristics and effects of the specific embodiments and other related contents of the present application, and cannot be considered as limitations to the present application.

[0059] In the drawings:

[0060] Figure 1 Method step diagram of steps S101 to S106 of the management method described in the specific embodiments;

[0061] Figure 2 Method step diagram of steps S201 to S205 of the management method described in the specific embodiments;

[0062] Figure 3 Method step diagram of steps S301 to S304 of the management method described in the specific embodiments;

[0063] Figure 4 Overall flowchart of the management method described in the specific embodiments;

[0064] Figure 5 Structure diagram of the management platform described in the specific embodiments. DETAILED DESCRIPTION

[0065] In order to explain the possible application scenarios, technical principles, specific schemes that can be implemented, and the purposes and effects that can be achieved of the present application in detail, the following will be described in combination with the specific embodiments listed and the accompanying drawings. The embodiments recorded in the present text are only used to more clearly explain the technical solutions of the present application, and therefore only serve as examples, and cannot limit the protection scope of the present application.

[0066] In the present text, the term “embodiment” means that the specific features, structures or characteristics described in combination with the embodiments can be contained in at least one embodiment of the present application. The term “embodiment” appearing at various positions in the specification does not necessarily refer to the same embodiment, and does not particularly limit the independence or association between other embodiments. In principle, in the present application, as long as there is no technical contradiction or conflict, each technical feature mentioned in each embodiment can be combined in any manner to form a corresponding implementable technical solution.

[0067] Unless otherwise defined, the meanings of technical terms used in the present application are the same as those commonly understood by one of ordinary skill in the art to which the present application belongs; the use of related terms herein is only for the purpose of describing specific embodiments of the present application and is not intended to limit the present application.

[0068] In the description of the present application, the phrase "and / or" is a description of the logical relationship between objects, which means that there can be three relationships, for example, A and / or B, which means that there are three cases: A exists, B exists, and A and B exist at the same time. In addition, the character " / " herein generally represents that the associated objects before and after are a "or" logical relationship.

[0069] In the present application, the phrases such as "first" and "second" are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual quantity, primary and secondary, or order relationship between the entities or operations.

[0070] In the present application, without more limitation, the "includes", "contains", "has" or other similar open expressions used in the sentence are intended to cover non-exclusive inclusion, and these expressions do not exclude the presence of other elements in the process, method or product including the described elements, so that the process, method or product including a series of elements can not only include those limited elements, but also include other elements not explicitly listed, or also include the elements inherent to such process, method or product.

[0071] As the same as the understanding in the "Guidelines for Examination", in the present application, the expressions such as "greater than", "less than", "exceed" are understood as not including the number; the expressions such as "above", "below", "within" are understood as including the number. In addition, in the description of the embodiments of the present application, the meaning of "multiple" is more than two (including two), and similar expressions related to "multiple" are also understood in this way, for example, "multiple groups", "multiple times" and the like, unless otherwise explicitly limited.

[0072] In the description of the embodiments of the present application, the spatial-related expressions used, such as "center", "longitudinal", "transverse", "length", "width", "thickness", "up", "down", "front", "back", "left", "right", "vertical", "horizontal", "vertical", "top", "bottom", "inside", "outside", "clockwise", "counterclockwise", "axial", "radial", "circumferential", and the like, indicate the orientation or positional relationship based on the orientation or positional relationship shown in the specific embodiments or the drawings, and are only for the convenience of describing the specific embodiments of the present application or for the reader to understand, and are not intended to indicate or imply that the indicated device or component must have a specific position, a specific orientation, or be constructed or operated in a specific orientation, and therefore cannot be understood as a limitation on the embodiments of the present application.

[0073] The processor described in the embodiments of the present application can be implemented by hardware, firmware, software or a combination thereof, and can use at least one of circuit, single or multiple Application Specific Integrated Circuit (ASIC), Digital Signal Processor (DSP), Digital Signal Processing Device (DSPD), Programmable Logic Device (PLD), Field Programmable Gate Array (FPGA), Central Processing Unit (CPU), controller, microcontroller, microprocessor, and other physical, biological or chemical structures that can realize the same or equivalent functions as the above-mentioned processors, such as biological neurons, quantum computing units, DNA computing units, etc., so that the processor can execute part or all of the steps or any combination of the steps mentioned in the computer programs or methods of various embodiments of the present application.

[0074] The computer program involved in the embodiments can be stored in a computer device readable storage medium, including but not limited to magnetic disk, magnetic tape, magnetic card, floppy disk, flash memory, optical disc, optical card, read-only memory (ROM), random access memory (RAM), erasable programmable ROM (EPROM) and electrically erasable programmable ROM (EEPROM), etc., and also includes other biological, physical or chemical structures that can realize similar or equivalent functions as the above-mentioned storage media, such as DNA, RNA, protein and other units with information storage ability, etc. In specific embodiments, the storage medium involved can be one of the above-mentioned medium types, or a combination of the above-mentioned medium types. In different embodiments, the computer program involved in the embodiments can be stored in a single medium in a centralized manner, or stored in multiple media in a distributed manner. The storage medium containing the computer device readable storage medium can be a non-volatile memory or a random access memory. These computer device readable storage media can be built-in in the device, or connected with the device as an external device or part of the external device. In some embodiments, the storage medium with the computer device readable storage medium is deployed locally; in other embodiments, the storage medium can also be deployed remotely from the processor, such as network attached storage accessed via RF circuit or external port and communication network, wherein the communication network can be Internet, one or more intranets, local area network (LAN), wide area network (WAN), storage area network (SAN) and the like, or appropriate combination thereof, as long as the access of the computer device to the storage medium can be realized. In addition, the computer program involved in the embodiments can be stored in plaintext / ciphertext, or can be designed as training data, and integrated and reorganized in the parameter state of the deep neural network or other machine learning model by means of model training.

[0075] Please refer to Figure 1 In the first aspect, the embodiment provides an AI large model based intelligent Bug management method, which comprises:

[0076] S101, collecting multi-source Bug data according to a preset rule, wherein the multi-source Bug data comprises structured error code, unstructured log text and development communication record;

[0077] S102, preprocessing the multi-source Bug data to obtain standardized Bug features, wherein the standardized Bug features comprise error description with unified semantic representation, code context parsed by abstract syntax tree and associated version information;

[0078] S103, performing semantic matching on the standardized Bug features based on CodeBERT large model to generate a set of historical similar Bug cases, and performing Bug trigger logic chain analysis based on AST abstract syntax tree to obtain problem code segment;

[0079] S104、Binding project technology stack features, historical similar Bug case set and problem code segment, generating repair scheme, repair scheme including code modification suggestion adapting technology stack, automatically generated repair code segment and implementation risk assessment;

[0080] S105、According to the repair scheme, construct the triple knowledge graph, and optimize the accuracy of the triple knowledge graph through reinforcement learning;

[0081] S106、The standardized Bug features, problem code segment, repair scheme and knowledge graph are associated to obtain Bug diagnosis result and output.

[0082] In step S101, multi-source Bug data is the basic input of intelligent diagnosis, in which structured error code is extracted through version control system, including complete exception stack and variable state; Unstructured log text can be obtained through log collection system, which records the detailed event stream during program running; Development communication record is exported from project management platform, which contains the discussion content of the developer on Bug phenomenon. These data are preliminarily cleaned through preset ETL rules to ensure the integrity of subsequent processing.

[0083] In step S102, the pre-processing process adopts multi-stage feature engineering, and the error description with unified semantic representation is converted into standardized vector representation through natural language processing technology; The code context parsed by abstract syntax tree is extracted by static analysis tool to extract variable scope and control flow relationship; The associated version information is extracted from the code submission history to extract dependent library version and module change record. The standardized Bug features output in this step have unified feature dimension and timestamp alignment.

[0084] In step S103, preferably, the CodeBERT large model maps the standardized Bug features to the shared semantic space through the pre-trained code understanding ability, and the generation of the historical similar Bug case set adopts k-nearest neighbor algorithm to search in the vector database; AST abstract syntax tree is an abstract representation of source code syntax structure, which is used to describe the syntax structure and logical relationship of code, and is convenient for computer program analysis and processing, which is used to analyze code logic to locate bug trigger condition in this embodiment. Specifically, AST abstract syntax tree analysis locates the logic path that triggers abnormal execution by establishing data dependency relationship between syntax nodes, and finally determines the problem code segment containing complete defect propagation chain.

[0085] In step S104, the generation of the repair scheme adopts a multi-modal fusion strategy. Preferably, the project technology stack features are obtained by analyzing pom.xml or package.json configuration files; the automatically generated repair code snippets are based on pattern matching and code completion technology; and the implementation risk assessment is calculated by analyzing the influence range of code changes and test coverage.

[0086] In step S105, the construction of the triple knowledge graph can adopt pattern-based entity relationship extraction to convert technical elements in the repair scheme into triple structure; preferably, the reinforcement learning optimization process evaluates the accuracy improvement effect of the knowledge graph in subsequent Bug diagnosis by designing a reward function to continuously adjust the entity linking strategy.

[0087] In step S106, the association process can adopt graph database technology to establish multidimensional indexes between elements, standardized Bug features as query conditions, problem code segments and repair schemes as vertices, and relationship paths in the knowledge graph as edges. The final output of the Bug diagnosis result contains complete causal reasoning chains and visual dependency relationship graphs.

[0088] The embodiment realizes the intelligentization of the whole process of Bug diagnosis by integrating the intelligent collection and standardized processing of multi-source Bug data, combining the semantic understanding ability of the CodeBERT large model and the code logic analysis of the AST abstract syntax tree. The standardized Bug features based on unified semantic representation eliminate the ambiguity of manual description and improve the problem positioning efficiency; through the dynamic matching of the historical similar Bug case set and the project technology stack features, the generated repair scheme has adaptability and accuracy; the continuous optimization of the triple knowledge graph realizes the automatic precipitation of development experience, and the application of the graph database technology ensures the explainability and visual presentation of the diagnosis result. The embodiment significantly improves the intelligent level of Bug management and the knowledge reuse efficiency.

[0089] Please refer to Figure 2 In some embodiments, the multi-source Bug data is preprocessed to obtain standardized Bug features, including:

[0090] S201, regular cleaning is performed on unstructured log text to remove garbled characters and redundant characters to obtain error descriptions;

[0091] S202, the error descriptions are semantically standardized by a BERT word vector model, and bug symptoms with the same meaning but different expressions are mapped to a unified semantic representation;

[0092] S203, element features in the structured error code are extracted using a code parsing tool, including class name, function name, and call chain relationship;

[0093] S204, time-space alignment of version change information in development communication records, error codes and log texts is performed to establish a version association relationship;

[0094] S205, feature fusion is performed on the preprocessed unified semantic representation, element features and version association relationship to generate standardized Bug features including unified semantic error description, code context features and version association information.

[0095] In step S201, the unstructured log text is original log information generated during system operation. Through preset regular expression pattern matching, the log text can effectively identify and remove redundant content such as garbled characters and timestamp prefixes, and retain the core error description. The regular cleaning process uses a multi-layer filtering mechanism to remove non-printable characters first, and then customizes cleaning rules for specific log formats. The final error description has a standardized text structure.

[0096] In step S202, the BERT word vector model maps the cleaned error description to a unified semantic space through pre-trained language understanding capabilities. Synonymous but differently expressed bug symptoms such as "connection timeout" and "request response timeout" are classified into the same semantic representation through vectorization processing and similarity calculation. Preferably, the process uses an attention mechanism to capture the context relationship of key words to ensure the accuracy of semantic standardization.

[0097] In step S203, the code parsing tool processes structured error codes through static analysis techniques. Element feature extraction includes three levels: class name is obtained through package path analysis, function name is identified through method signature, and call chain relationship is reconstructed through analysis of nested call sequences in stack traces. These element features together constitute a complete representation of the code context, providing a structured reference for subsequent problem localization.

[0098] In step S204, the time-space alignment of version change information and error data uses a double matching strategy: in the time dimension, log events and code commit records are aligned through millisecond-accurate timestamps; in the spatial dimension, the impact range of code changes is determined through module path mapping. The established version association relationship includes code version number, dependent library version and other key metadata, which can accurately reflect the technical environment of bug generation.

[0099] In step S205, the feature fusion process preferably uses a multi-modal attention mechanism. The unified semantic error description provides features in the natural language dimension, the code context features contribute syntax structure information, and the version association information injects environmental configuration dimension features. The weighted fusion of the three can be realized through a feature gating mechanism to dynamically allocate weights. The final generated standardized Bug features have comprehensive representation capabilities in cross-modal and multi-dimensional dimensions.

[0100] The original multi-source bug data is converted into machine-understandable standardized features through a hierarchical preprocessing process. For example, when processing the "database connection pool depletion" error, the regular cleaning retains the core description, the BERT model standardizes it to "connection resource shortage", the code parsing extracts the connection pool configuration related class methods, the version association locks the latest database driver upgrade record, and the finally fused features can accurately reflect the technical essence of the problem, laying a high-quality data foundation for subsequent intelligent analysis.

[0101] Please refer to Figure 3 In some embodiments, the standardized bug features are semantically matched based on the CodeBERT large model to generate a set of historical similar bug cases, including:

[0102] S301, the standardized bug features are multi-dimensionally semantically encoded by the encoder layer of the CodeBERT large model to generate a deep semantic vector;

[0103] S302, the cosine similarity between the deep semantic vector and the historical standardized bug feature vector of each historical bug case in the historical bug database is calculated, and a dynamic similarity threshold is set, which is automatically adjusted according to the current multi-source bug data distribution characteristics;

[0104] S303, based on the cosine similarity obtained by calculation one by one, the historical bug cases exceeding the dynamic similarity threshold are screened out, which are recorded as candidate historical bug cases;

[0105] S304, the candidate historical bug cases are sorted from high to low according to the cosine similarity, and the first preset number of candidate historical bug cases with the highest cosine similarity after sorting are aggregated to generate a set of historical similar bug cases.

[0106] In step S301, the encoder layer of the CodeBERT large model is implemented by a multi-layer Transformer structure, and when the standardized bug features are multi-dimensionally semantically encoded, the features input of three dimensions of natural language description, code context features and version association information are considered. The generation process of the deep semantic vector adopts an attention mechanism to dynamically weight different feature dimensions, and the finally output vector representation contains not only code features at the syntax level, but also error descriptions at the semantic level.

[0107] In step S302, the cosine similarity calculation can adopt a normalized dot product method to measure the angle distance of the current deep semantic vector and the historical standardized Bug feature vector in the vector space. The adjustment mechanism of the dynamic similarity threshold is realized by analyzing the feature distribution density of the current multi-source Bug data. When the data distribution is sparse, the threshold is appropriately reduced to expand the search range, and when the distribution is dense, the threshold is increased to ensure the matching accuracy. The dynamic similarity threshold adjustment process does not require manual intervention and automatically completes parameter optimization through the clustering characteristics of historical case vectors.

[0108] In step S303, preferably, the screening of alternative historical Bug cases adopts a double verification mechanism, first based on cosine similarity for preliminary screening, and then through additional semantic consistency check to ensure the relevance of the matching cases. The semantic consistency check mainly verifies the degree of coincidence of the matching cases in the two dimensions of code context features and version association information, avoiding false matching caused by relying only on text similarity.

[0109] In step S304, the sorting process considers multiple factors: cosine similarity as the main sorting indicator, while the time decay factor of the reference case is considered to give appropriate weighting to recent cases. The determination of the pre-set number is based on the needs of actual application scenarios, and is usually set to 5-10 cases to balance coverage and search efficiency. The final aggregation operation not only retains the original case information, but also extracts the common symptom-cause pattern to form a structured set representation.

[0110] The present embodiment realizes accurate historical case retrieval through a multi-level semantic matching mechanism. For example, when dealing with the "null pointer exception" problem, the encoder layer will analyze the error description text, the object call chain involved, and the related framework version information, and the generated deep semantic vector can accurately represent the technical features of the exception. Through dynamic threshold controlled similarity matching, similar historical cases with reference value can be intelligently screened out to provide reliable decision basis for subsequent repair scheme generation. The present embodiment effectively solves the limitations of traditional keyword matching methods in complex technical scenarios through the retrieval method based on multi-dimensional semantic understanding.

[0111] In some embodiments, the Bug triggering logic chain is analyzed based on the AST abstract syntax tree to obtain the problem code segment, including:

[0112] The error code contained in the standardized Bug feature is parsed in syntax to construct a complete AST abstract syntax tree;

[0113] Starting from the root node of the AST abstract syntax tree, the syntax nodes associated with the unified semantic representation of the error description are marked out layer by layer along the call chain relationship;

[0114] extracting the marked syntax node and its directly associated context nodes to form a candidate question code segment set;

[0115] performing path simulation on each code segment in the candidate question code segment set, screening out a code segment that actually triggers the uniform semantic error description, and recording the code segment as a problem code segment.

[0116] In the embodiment, the construction of the AST abstract syntax tree can be realized by a static code analysis tool, and the error code in the standardized Bug feature is converted into a tree structure representation, where each syntax node corresponds to a specific syntax element (such as class declaration, method call, etc.) in the code. The root node represents the syntax structure of the entire code file, and the child nodes are refined layer by layer to the expression level.

[0117] The call chain relationship traversal starting from the root node can adopt a depth-first search strategy, and the syntax nodes related to the uniform semantic error description are identified through a predefined error pattern matching rule. The marking process records the type, position and data flow relationship with other nodes of the node, ensuring that the key syntax elements are not missed.

[0118] The generation of the candidate question code segment set considers the topological relationship of the syntax nodes, and the marked nodes and their directly associated context nodes jointly constitute the boundary range of the candidate paragraph. The execution path simulation is realized through symbolic execution technology, which deduces the possible execution flow without actually running the code, and finally determines the problem code segment that actually triggers the error by comparing the simulation result with the characteristics of the uniform semantic error description.

[0119] The embodiment accurately identifies the problem code segment by combining static analysis of AST with dynamic simulation. For example, when processing the "array out-of-bound exception", the AST analysis first locates all array access nodes, and then determines the access point that actually triggers the out-of-bound through execution path simulation, effectively avoiding the misjudgment that may be caused by simply relying on static analysis.

[0120] In some embodiments, a repair scheme is generated in combination with the project technology stack features, the historical similar Bug case set and the problem code segment, including:

[0121] A technology stack adaptation layer is constructed based on the project technology stack features, and the technology stack adaptation layer is used to convert the repair scheme format into an expression form that meets the preset expression conditions;

[0122] The historical repair strategies associated with each candidate historical Bug case are extracted from the historical similar Bug case set, and the association weights of the historical repair strategies and the current problem code segment are calculated through an attention mechanism;

[0123] The historical repair strategies are weighted and fused according to the association weights to generate a preliminary repair scheme, and the syntax compatibility of the preliminary repair scheme with the problem code segment is verified.

[0124] The preliminary repair solution that passes the verification is input into the technical stack adaptation layer for format conversion, and the final repair solution that meets the requirements of the current project technical stack is output.

[0125] In this embodiment, the technical stack adaptation layer identifies the technical stack characteristics through the project configuration file, including programming language version, framework type, and dependency library constraints, and other elements. Preferably, the technical stack adaptation layer uses a template conversion engine to convert the general code patterns in the repair solution into an expression form that meets the specific technical specifications of the project, ensuring that the generated repair code can be directly integrated into the existing code base.

[0126] The extraction process of historical repair strategies analyzes the repair records of the alternative historical Bug cases, retaining complete code modification fragments and associated comments. The implementation of the attention mechanism compares the similarity of the current problem code segment with the AST structure of the historical cases, and calculates the association weight based on the code context features, so that historical repair strategies with high relevance have greater influence.

[0127] The generation of the preliminary repair solution uses code snippet fusion technology to selectively combine historical repair strategies based on association weights, while maintaining the integrity of the syntax structure. Syntax compatibility verification ensures seamless integration of the repair solution with the problem code segment through static type checking and code style analysis. The final format conversion process adjusts API calling methods, code format specifications, and other detailed elements according to the characteristics of the project technical stack.

[0128] This embodiment realizes the standardized conversion of repair solutions through the technical stack adaptation layer, and combines the attention mechanism to weight and fuse historical repair strategies, ultimately generating repair solutions that match the characteristics of the project technical stack. Through the format conversion of the technical stack adaptation layer, it ensures that the repair solution meets the specific technical specifications of the project, avoiding compatibility issues caused by differences in technical stacks; the weight distribution based on the attention mechanism can intelligently select the most relevant historical repair strategies, improving the relevance and effectiveness of the repair solution; syntax compatibility verification ensures seamless integration of the repair code with the problem code segment, preserving the value of historical repair experience while adapting to the technical requirements of the current project, thereby significantly improving the accuracy and engineering applicability of Bug repair.

[0129] In some embodiments, historical repair strategies associated with each alternative historical Bug case are extracted from a set of historical similar Bug cases, and the association weight of each historical repair strategy with the current problem code segment is calculated through the attention mechanism, including:

[0130] The problem code segment is converted into a problem feature vector through the word embedding layer, and each historical repair strategy is converted into a corresponding historical strategy feature vector;

[0131] A multi-head attention network is constructed to calculate the cross-modal similarity between the problem feature vector and each historical strategy feature vector, and generate an initial attention score;

[0132] The success rate of repair in the historical similar bug case set is introduced as prior knowledge to weight and correct the initial attention score to obtain a normalized correlation weight.

[0133] According to the normalized correlation weight, a historical repair strategy that exceeds a preset correlation threshold is selected as an effective repair strategy, and the normalized correlation weight corresponding to the effective repair strategy is recorded as a correlation weight.

[0134] In this embodiment, the word embedding layer is implemented by using a pre-trained language model to convert the code text and annotation information in the problem code segment and the historical repair strategy into high-dimensional vector representations. The problem feature vector represents the semantic and structural features of the current code to be repaired, and the historical strategy feature vector captures the key modification patterns and technical points of the historical repair cases. The vector conversion process preserves the syntax structure and logical relationship of the code, providing accurate feature representation for subsequent similarity calculation.

[0135] The multi-head attention network is composed of multiple parallel attention heads, each of which calculates the cross-modal similarity between the problem feature vector and the historical strategy feature vector through different linear transformation matrices. Preferably, the generation of the initial attention score adopts the scaled dot-product attention mechanism, which measures the relevance of the current problem and each historical repair strategy through query-key value matching. The introduction of prior knowledge is realized by constructing a mapping function between the repair success rate and the attention score. This function dynamically adjusts the initial score based on the actual repair effect of historical cases, so that the effective repair strategies that have been verified obtain higher weights.

[0136] Preferably, the normalized correlation weight is processed by a softmax function to ensure that the sum of all weights is 1. The preset correlation threshold is set by considering the number and quality of historical repair strategies, and is usually taken as the top 30% quantile of the normalized weight distribution as the screening standard. The selection of effective repair strategies takes into account both the semantic similarity with the current problem and the actual effectiveness of historical repair strategies, thereby ensuring that the final repair scheme has both pertinence and reliability.

[0137] This embodiment realizes precise matching at the code semantic level through feature vector conversion and multi-head attention mechanism. For example, in handling null pointer exception problems, the word embedding layer can identify code patterns with different variable naming but the same exception type, and the multi-head attention mechanism can focus on multiple dimensions of similarity such as exception trigger conditions and repair methods, finally selecting the most relevant effective repair strategy, which not only makes full use of historical repair experience, but also ensures the best adaptability to the current problem through intelligent weight calculation.

[0138] In some embodiments, according to the repair scheme, a triple knowledge graph is constructed, comprising:

[0139] Repair elements are extracted from the repair scheme, including error types, repair operations and code contexts;

[0140] The repair elements are taken as entity nodes of the knowledge graph;

[0141] Based on the version association information in the standardized Bug features, the version evolution relationship between each entity node is established to form the relationship edges of the knowledge graph;

[0142] The entity nodes and relationship edges are organized according to the triple structure of error type-repair operation-code context to generate an initial knowledge graph;

[0143] The initial knowledge graph is embedded and represented by a graph neural network to generate a dynamic knowledge graph with version perception ability, denoted as a triple knowledge graph.

[0144] In this embodiment, the extraction of repair elements is realized by code static analysis technology, the error types include exception categories and defect patterns, the repair operations cover code modification actions and patch contents, and the code context contains the class, method and calling relationship where the problem code is located. These elements together constitute the basic semantic units of the knowledge graph, providing structured data for subsequent knowledge organization.

[0145] The construction of entity nodes adopts a typed node representation method, in which the error type node is associated with the defect classification system, the repair operation node records the specific modification method, and the code context node maintains the complete code location information. The establishment of the version evolution relationship is realized by analyzing the version number, release time and modification record in the standardized Bug features to form a time sequence relationship edge reflecting the evolution process of the repair scheme.

[0146] The organization of the triple structure takes the error type as the head entity, the repair operation as the relationship, and the code context as the tail entity. The embedding representation learning of the graph neural network adopts a time sequence graph attention network to enhance the entity representation by aggregating the version information of adjacent nodes, so that the generated dynamic knowledge graph can reflect the evolution law of the repair scheme between different versions.

[0147] The embodiment repairs the elements by constructing a triple knowledge graph structure for structured storage, and learns the version evolution relationship by using a graph neural network to form a repair knowledge system with timing characteristics. The triple structure associates error types, repair operations and code context to form a complete repair knowledge expression framework. The introduction of the version evolution relationship enables the knowledge graph to have dynamic evolution capability and trace the iteration process of the repair scheme. The embedding learning of the graph neural network enhances the unity and computability of the knowledge representation, retains the specific implementation details of the repair scheme, and establishes semantic association across versions, providing more comprehensive and accurate knowledge support for subsequent repair of similar problems.

[0148] In some embodiments, the accuracy of the triple knowledge graph is optimized by reinforcement learning, including:

[0149] A reinforcement learning environment is constructed to include problem code segment entities, repair scheme entities and technical stack features, and the embedding representation of the entity nodes of the triple knowledge graph is taken as the state space;

[0150] A composite reward function is generated based on the feedback of the implementation results of the repair scheme, including version evolution consistency, code modification effectiveness and risk control compliance rate;

[0151] The prediction weight of the entity relationship in the triple knowledge graph is iteratively optimized by the policy network to automatically correct the accuracy.

[0152] In the embodiment, the construction of the reinforcement learning environment is realized by taking the actual repair cases in the code repository as training samples. The problem code segment entity contains defect features and context information, the repair scheme entity records specific modification content, and the technical stack feature covers environmental factors such as programming language and framework version. The representation of the state space uses the aggregation result of the knowledge graph node embedding vector, which completely retains the semantic information of the triple structure.

[0153] The generation of the composite reward function takes into account the actual effect of the repair scheme. The version evolution consistency evaluates whether the modification scheme conforms to the iterative trend of the technical stack, the code modification effectiveness verifies whether the defect is correctly repaired, and the risk control compliance rate measures the risk of new problems introduced by the modification. The policy network is implemented by using a deep reinforcement learning framework. The action value function is used to evaluate the optimization direction of the prediction weight of different entity relationships, and the reasoning logic of the knowledge graph is automatically adjusted to maximize the long-term cumulative reward.

[0154] The embodiment integrates the actual repair effect feedback into the knowledge graph optimization process by reinforcement learning. For example, when dealing with the problem of database connection leakage, the system will automatically adjust the association weight between the connection pool configuration scheme and the specific framework version according to the actual running effect of different repair schemes, continuously improving the prediction accuracy of the knowledge graph.

[0155] The embodiment dynamically optimizes the triple knowledge graph through reinforcement learning mechanism, and feeds back the actual implementation effect of the repair scheme into the iteration process of the knowledge graph. The composite reward function comprehensively evaluates the repair scheme quality from three dimensions of version evolution consistency, code modification effectiveness and risk control, ensuring that the optimization direction meets the actual engineering requirements; the strategy network adjusts the entity relationship prediction weight continuously, so that the knowledge graph has self-correction ability and can adapt to the evolution of technology stack; the reinforcement learning environment based on actual repair cases ensures the pertinence and practicality of the optimization process, so that the recommendation results of the knowledge graph are more accurate and reliable, and the decision quality of automatic repair is effectively improved.

[0156] In some embodiments, multi-source bug data is collected according to preset rules, including:

[0157] The commit message containing the error repair description is extracted as the first data source by real-time monitoring of the submission record of the project code repository through the API interface;

[0158] The static analysis tool is configured to scan the code library, and the detected potential defects and associated code fragments are taken as the second data source;

[0159] The structured error code is generated by integrating the first data source and the second data source;

[0160] The bug reports and their solutions whose state markers are "fixed" in the project management system are screened as the third data source;

[0161] The third data source is split into unstructured log text and development communication records;

[0162] The multi-source bug data is generated.

[0163] In the embodiment, the collection of multi-source bug data is realized through three complementary data sources, ensuring the comprehensiveness and reliability of error repair information. The commit message containing the error repair description is taken as the first data source by real-time monitoring of the submission record of the project code repository through the API interface, which is used to obtain the repair behavior explicitly marked by the developer; the potential defects and associated code fragments detected by the static analysis tool constitute the second data source, which supplements the actual existing code problems that are not explicitly marked.

[0164] The generation of structured error code is realized by analyzing the association between the first data source and the second data source, and matching and integrating the explicit repair and potential defects. The bug reports and their solutions whose state markers are "fixed" in the project management system are taken as the third data source, which can be split into unstructured log text and development communication records through natural language processing technology, and the original information of problem description and solution process is retained respectively.

[0165] The embodiment constructs a complete error repair evidence chain through multi-dimensional data collection. For example, for a null pointer exception problem, the repair method can be obtained from the commit message, similar defect patterns can be found through static analysis, and the complete Bug data set containing code modification, problem description and solution can be finally formed by combining the discussion process in the work order record.

[0166] The embodiment constructs a complete error repair knowledge system through a multi-source Bug data collection mechanism. Through the collaborative collection of three complementary data sources of API interface, static analysis tool and project management system, the developer's explicit repair behavior is obtained, potential defect patterns are captured, and the complete context of the problem solving process is retained. The combination of structured error code and unstructured log text and development communication records ensures the machine readability of the data and retains the decision logic of human engineers. This multi-dimensional data integration method provides a comprehensive and accurate data basis for subsequent knowledge graph construction, making the extraction of error repair knowledge more systematic and standardized, and effectively improving the coverage and accuracy of defect analysis.

[0167] In a second aspect, the embodiment also provides an intelligent Bug management platform based on an AI large model, which is suitable for the method of the first aspect.

[0168] In the embodiment, the intelligent Bug management platform based on the AI large model is a system platform specially used to implement the foregoing multi-source Bug data collection and knowledge graph optimization method, and includes a data collection module, a preprocessing module, an AI analysis engine, a solution generation module and a knowledge base management module. The data collection module seamlessly connects Jira, GitLab and other development and operation tools through an API interface, and listens to code submission events in real time. The preprocessing module uses regular expressions and named entity recognition technology to realize data cleaning and feature extraction. The AI analysis engine integrates a semantic matching sub-engine and a code understanding sub-engine, and performs intelligent analysis based on a CodeBERT code large model. The solution generation module internally stores industry standard repair templates and supports custom extension. The knowledge base management module uses a RAG architecture to realize dynamic retrieval and updating of knowledge. The platform converts the method of the first aspect into a complete system implementation, which not only provides a carrier for method implementation, but also ensures the dynamic optimization capability of the knowledge graph.

[0169] Further, the following examples can be developed in combination with the above technical solutions:

[0170] The application provides an intelligent bug management method and platform based on an AI large model. Through AI large model and multi-source data fusion, a closed-loop management system of "data collection-intelligent analysis-precise repair-knowledge depositing" is constructed, solving the efficiency and accuracy pain points in traditional bug management.

[0171] Please refer to Figure 4 The overall process of the management method is as follows:

[0172] Multi-source data collection: Multi-source data collection covers two types of key data, structured and unstructured. Structured data includes bug management tools, error codes, module attribution, and test case results, which are stored in a clear and standardized format for quick retrieval and analysis. Unstructured data includes log files that record system operation details, Git commit information that retains code change history, and development team problem discussion and communication records. Although these data have flexible formats, they can provide rich context scenarios, and the two complement each other to lay a data foundation for accurate positioning and efficient bug solving.

[0173] Data preprocessing: Data preprocessing is a key step to realize intelligent analysis. It optimizes the original data through three core links. First, text cleaning is performed to remove garbled characters, special characters and redundant information in logs using regular expressions to improve data quality. Then semantic standardization is carried out to map synonyms such as "page lag" and "front-end response delay" into unified semantic representations using BERT word vector models to eliminate language ambiguity. Finally, feature extraction is performed to automatically identify code elements (such as class name, function name) and error context (such as call chain level) using code analysis tools and deep learning models to provide standardized features for subsequent intelligent analysis and prediction.

[0174] AI large model analysis:

[0175] Adopting "code large model + bug knowledge graph" architecture;

[0176] Basic model: Based on CodeBERT / CodeGPT pre-training, understanding code logic and bug association;

[0177] Knowledge graph: Constructing a triple (such as "network request failure → cross-domain configuration error → modify nginx.conf") of "symptom-reason-solution".

[0178] Analysis dimension:

[0179] Semantic similarity calculation: Match historical similar bugs through vector retrieval;

[0180] Code context inference: Analyze bug trigger conditions (e.g., "unhandled Promise reject") in combination with AST abstract syntax tree.

[0181] Impact scope prediction: Evaluate the potential impact of the bug on other modules (e.g., "database connection pool configuration error → server crash risk").

[0182] Repair scheme recommendation:

[0183] Dynamic generation scheme: The system automatically adapts to the project technology stack, such as identifying a Vue project, and prioritizing the use of Vue Devtools for debugging.

[0184] Code snippet generation: The system automatically generates repair code blocks (e.g., adding null checks for null pointer exceptions).

[0185] Risk assessment: The system conducts risk assessment on the recommended scheme, clearly marking the implementation cost, such as "2 files need to be modified, estimated time 1.5 hours."

[0186] Knowledge base closed-loop update: When the developer confirms and applies the repair scheme, the system automatically structures the new case and stores it in the knowledge base, achieving real-time knowledge sedimentation and sharing. At the same time, with the help of reinforcement learning technology, the model is dynamically optimized. Once the prediction accuracy of a certain type of bug is lower than 80%, the system will automatically trigger the sample expansion process, collect more relevant cases, and start the model fine-tuning program, continuously improving the accuracy of prediction and the effectiveness of repair schemes, forming a virtuous cycle of "practice-feedback-optimization."

[0187] Please refer to Figure 5 , the modules of the management platform are described as follows:

[0188] The intelligent bug management platform includes data collection module, preprocessing module, AI analysis engine, scheme generation module, knowledge base management module, which are described as follows:

[0189] 1) Data collection module: The data collection module seamlessly connects Jira, GitLab,

[0190] ELK, etc. 20+ mainstream development and operation tools through API interface, realizing the unified collection of structured and unstructured data. At the same time, this module uses event-driven mechanism to listen to code submission events in real time, accurately captures bug repair information contained in Git commit remarks, ensures that various data generated during development can be collected timely and completely, and provides comprehensive and fresh data support for subsequent data preprocessing and intelligent analysis.

[0191] 2) Pretreatment module: for unstructured logs, with the help of regular expressions and rule engines, accurately remove interference information such as garbled codes, redundant characters, etc., and realize the preliminary cleaning of data; at the same time, by using named entity recognition (NER) technology, automatically capture key entities in log and code text, such as class name, function name and other code elements, and convert unstructured data into structured features, providing standardized and high-quality data basis for subsequent AI analysis.

[0192] 3) AI analysis engine: the AI analysis engine integrates a semantic matching sub-engine and a code understanding sub-engine. The former calculates bug similarity based on a double-tower model and can quickly match similar historical problems. The latter accurately locates the problem code segment by analyzing the AST abstract syntax tree. The engine also supports multi-round dialogue analysis. When the developer asks follow-up questions (such as "Is the bug related to the recently deployed version?"), the model can automatically associate version change logs and provide more in-depth analysis results.

[0193] 4) Solution generation module: the solution generation module is designed with the core design concept of standardization and flexibility. It has more than 200 built-in industry standard repair templates covering microservice fuse processing, front-end resource loading optimization and other scenarios, which can be directly adapted to mainstream development scenarios. At the same time, it supports teams to extend functions through custom templates, upload internal best practice cases, form a repair solution library with both standardization and individualization, and help development teams efficiently output accurate repair strategies.

[0194] 5) Knowledge base management module: the knowledge base management module uses the RAG (Retrieval Augmentation Generation) architecture to ensure that the latest project data is called first when recommending repair solutions through a dynamic retrieval mechanism, ensuring the timeliness and adaptability of knowledge. At the same time, it provides a visual knowledge graph editing interface that supports domain experts to manually optimize the association between nodes such as "symptom-reason-solution" through drag-and-drop, labeling and other operations, realizing the deep integration of AI intelligent recommendation and manual experience, and continuously improving the accuracy and practicality of the knowledge base.

[0195] By adopting the above technical solutions, the present application is different from the prior art and has the following beneficial effects:

[0196] Through intelligent collection and standardized processing of multi-source Bug data fusion, combined with the semantic understanding ability of CodeBERT large model and the code logic analysis of AST abstract syntax tree, a complete intelligent Bug management system is constructed. In the aspect of problem positioning, the standardized Bug features based on unified semantic representation eliminate the ambiguity of manual description, and through the semantic matching sub-engine, the historical similar cases are quickly retrieved, combined with the AST analysis to accurately locate the problem code segment, which greatly improves the defect diagnosis efficiency; in the aspect of repair scheme generation, the technical stack adaptation layer ensures that the repair suggestion conforms to the project specification, the attention mechanism weightedly fuses the historical repair strategies, automatically generates the code segment and evaluates the implementation risk, which significantly improves the repair accuracy and engineering applicability; in the aspect of knowledge management, the triple knowledge graph structure stores the repair experience, the reinforcement learning mechanism continuously optimizes the entity relationship, and the RAG architecture guarantees the timeliness of knowledge retrieval, forming a sustainable evolution of repair knowledge system. Through the closed-loop management of 'data collection-intelligent analysis-accurate repair-knowledge sedimentation', this embodiment realizes the intelligent upgrading of the whole process of Bug processing, not only improves the efficiency and quality of single defect repair, but also continuously optimizes the overall development process through knowledge accumulation, providing a reliable solution for software engineering quality management.

[0197] Finally, it should be noted that although the above embodiments have been described in the specification and drawings of the present application, they do not limit the patent protection scope of the present application. Any technical solution obtained by replacing or modifying the equivalent structure or equivalent process based on the essential concept of the present application, using the content described in the specification and drawings of the present application, and directly or indirectly implementing the technical solutions of the above embodiments in other related technical fields, etc., are all included in the patent protection scope of the present application.

Claims

1. An AI large model-based intelligent bug management method, characterized in that, The method comprises the following steps: Collecting multi-source Bug data according to preset rules, wherein the multi-source Bug data comprises structured error codes, unstructured log texts and development communication records; Preprocessing the multi-source Bug data to obtain standardized Bug features, wherein the standardized Bug features comprise error descriptions in unified semantic representation, code contexts parsed by abstract syntax trees and associated version information; Performing semantic matching on the standardized Bug features based on a CodeBERT large model to generate a set of historical similar Bug cases, and analyzing Bug trigger logic chains based on AST abstract syntax trees to obtain problem code segments; Generating a repair scheme based on the project technology stack features, the set of historical similar Bug cases and the problem code segments, wherein the repair scheme comprises code modification suggestions adapted to the technology stack, automatically generated repair code segments and implementation risk assessments; According to the repair scheme, a triple knowledge graph is constructed, and the accuracy of the triple knowledge graph is optimized through reinforcement learning; The standardized Bug features, problem code segments, repair schemes and knowledge graphs are associated to obtain Bug diagnosis results and output. 2.The AI large model-based intelligent bug management method of claim 1, wherein, The preprocessing of the multi-source Bug data to obtain standardized Bug features comprises: Regular cleaning of the unstructured log texts to remove garbled codes and redundant characters to obtain error descriptions; Performing semantic standardization on the error descriptions through a BERT word vector model to map bug symptoms with the same meaning but different expressions into unified semantic representation; Extracting element features from the structured error codes using a code analysis tool, wherein the element features comprise class names, function names and call chain relationships; Aligning version change information in the development communication records with the error codes and log texts in time and space to establish version association relationships; Feature fusion of the preprocessed unified semantic representation, element features and version association relationships to generate standardized Bug features comprising unified semantic error descriptions, code context features and version association information. 3.The AI-large model-based intelligent bug management method of claim 1, wherein, The semantic matching on the standardized Bug features based on the CodeBERT large model to generate a set of historical similar Bug cases comprises: Multi-dimensional semantic encoding of the standardized Bug features through the encoder layer of the CodeBERT large model to generate deep semantic vectors; Calculating the cosine similarity between the deep semantic vectors and the historical standardized Bug feature vectors of each historical Bug case in the historical Bug database, and setting a dynamic similarity threshold that is automatically adjusted according to the current multi-source Bug data distribution characteristics; Based on the cosine similarities obtained by the one-by-one calculation, the historical Bug cases exceeding the dynamic similarity threshold are selected as candidate historical Bug cases; Sorting the candidate historical Bug cases in descending order of the cosine similarity, and aggregating the top pre-set number of candidate historical Bug cases with the highest cosine similarity to generate the set of historical similar Bug cases. 4.The AI large model-based intelligent Bug management method of claim 1, wherein, The analysis of Bug trigger logic chains based on AST abstract syntax trees to obtain problem code segments comprises: Syntax analysis is performed on the error code contained in the standardized Bug feature to construct a complete AST abstract syntax tree; Starting from the root node of the AST abstract syntax tree, the syntax nodes associated with the error description of the uniform semantic representation are marked out layer by layer along the call chain relationship; The marked syntax nodes and their directly associated context nodes are extracted to form a candidate problem code segment set; Each code segment in the candidate problem code segment set is subjected to execution path simulation to filter out the code segment that actually triggers the uniform semantic error description, which is recorded as the problem code segment. 5.The AI-large model based intelligent Bug management method of claim 1, wherein, Based on the project technology stack characteristics, the historical similar Bug case set and the problem code segment, a repair scheme is generated, including: A technology stack adaptation layer is constructed based on the project technology stack characteristics, which is used to convert the repair scheme format into an expression form that meets the pre-set expression conditions; From the historical similar Bug case set, the historical repair strategies associated with each alternative historical Bug case are extracted, and the association weight of each historical repair strategy with the current problem code segment is calculated through an attention mechanism; The historical repair strategies are weighted and fused according to the association weight to generate a preliminary repair scheme, and the syntax compatibility of the preliminary repair scheme with the problem code segment is verified; The preliminary repair scheme that passes the verification is input into the technology stack adaptation layer for format conversion, and the final repair scheme that meets the requirements of the current project technology stack is output. 6.The AI large model-based intelligent Bug management method of claim 5, wherein, From the historical similar Bug case set, the historical repair strategies associated with each alternative historical Bug case are extracted, and the association weight of each historical repair strategy with the current problem code segment is calculated through an attention mechanism, including: The problem code segment is converted into a problem feature vector through a word embedding layer, and each historical repair strategy is converted into a corresponding historical strategy feature vector; A multi-head attention network is constructed to calculate the cross-modal similarity between the problem feature vector and each historical strategy feature vector, generating an initial attention score; The success rate of repair in the historical similar Bug case set is introduced as prior knowledge to weight and correct the initial attention score to obtain a normalized association weight; According to the normalized association weight, historical repair strategies that exceed a pre-set association threshold are selected as effective repair strategies, and the normalized association weight corresponding to the effective repair strategies is recorded as the association weight. 7.The AI-large model based intelligent Bug management method of claim 1, wherein, According to the repair scheme, a triple knowledge graph is constructed, including: Repair elements are extracted from the repair scheme, including error type, repair operation and code context; The repair elements are used as entity nodes of the knowledge graph; Based on the version association information in the standardized Bug feature, the version evolution relationship between each entity node is established to form the relationship edges of the knowledge graph; The entity nodes and relationship edges are organized in a triple structure of error type-repair operation-code context to generate an initial knowledge graph; Through graph neural network embedding representation learning, a dynamic knowledge graph with version perception ability is generated, which is recorded as the triple knowledge graph. 8.The AI-large model based intelligent Bug management method of claim 1, wherein, The accuracy of the triple knowledge graph is optimized through reinforcement learning, including: A reinforcement learning environment is constructed including problem code segment entities, repair solution entities and technology stack features, and embedding representations of entity nodes of a triple knowledge graph are taken as a state space; A composite reward function is generated based on the implementation result feedback of the repair solution, including version evolution consistency, code modification effectiveness and risk control compliance rate; The prediction weight of entity relationship in the triple knowledge graph is iteratively optimized through a policy network to automatically correct the accuracy. 9.The AI-large model based intelligent bug management method of claim 1, wherein, According to a preset rule, multi-source Bug data is collected, including: A commit message containing an error repair description is extracted as a first data source by real-time monitoring of the submission record of the project code repository through an API interface; A static analysis tool is configured to scan the code library, and the detected potential defects and associated code segments are taken as a second data source; According to the first data source and the second data source, a structured error code is generated; Bug reports and their solutions whose status markers are "fixed" are selected as a third data source by parsing the work order records in the project management system; The third data source is split into unstructured log texts and development communication records; The multi-source Bug data is generated.

10. An AI large model-based intelligent bug management platform, characterized in that, The method is suitable for any one of claims 1 to 9.

Images