Intelligent repairing method and device for automatic assembly line construction errors and medium

Abstract

The invention discloses an intelligent repairing method and device for automatic assembly line construction errors and a medium, and relates to the field of continuous integration and continuous deployment of software. An intelligent repairing method for an automatic assembly line construction error comprises the steps that when failed assembly line code repairing cannot be carried out based on a target rule engine, a multi-modal feature vector of a task execution failure assembly line is obtained; retrieving code repair case data according to the multi-modal feature vector and a failure process code repair knowledge base; and when the similarity between the code repair case data and the key vector of the task execution failure assembly line is smaller than a target similarity threshold value, generating a target repair code according to the problem associated data of the multi-modal feature vector and a code generation model. According to the technical scheme provided by the embodiment of the invention, the strong dependence of automatic assembly line construction error repair on manpower can be broken through, and the error repair efficiency is greatly improved.

Description

Technical Field

[0001] This invention relates to the field of continuous software integration and continuous deployment technology, and in particular to an intelligent repair method, device and medium for automated pipeline construction errors. Background Technology

[0002] Currently, when CI (Continuous Integration) / CD (Continuous Deployment) pipeline builds fail, developers primarily rely on the following technical solutions for troubleshooting and repair: 1) Developers log into the CI / CD platform to view the build console output; in the lengthy and messy logs, they visually scan for keywords (such as "ERROR", "FAILED", "Exception") to locate the root cause of the error; based on the filename and line number hints in the error message, they open the corresponding file in the local integrated development environment and combine it with stack traces to address the issue. 2) Using a log management system to centrally store and index build logs; developers can locate error log fragments more efficiently than the original console output through keyword searches and filtering, but this is still an auxiliary method for manual analysis, and the core diagnostic and repair work still needs to be done manually.

[0003] Developers spend a significant amount of time conducting a "carpet-bombing" search through a vast sea of ​​logs to pinpoint specific errors. This tedious and time-consuming process severely slows down the development pace, and the speed and effectiveness of problem-solving depend entirely on the developer's technical skill, project familiarity, and troubleshooting experience. New employees often struggle with complex errors, and the same errors may be repeatedly encountered and resolved by different team members, creating "knowledge silos" and repetitive work. Experienced employees' problem-solving skills cannot be systematically passed on to other members; organizational knowledge is lost with staff turnover. Furthermore, the entire problem tracking and resolution process requires frequent switching between multiple tools, disrupting context, interrupting flow states, and involving multiple iterations, resulting in long feedback cycles and severely impacting work efficiency. Summary of the Invention

[0004] This invention provides an intelligent repair method, device, and medium for automated production line build errors, to solve the problems of existing automated production line build error repair relying heavily on manual labor and having low error repair efficiency.

[0005] According to one aspect of the present invention, an intelligent repair method for automated pipeline build errors is provided, comprising:

[0006] When the target rule engine is unable to repair the failed pipeline code, obtain the multimodal feature vector of the failed task execution pipeline;

[0007] Based on multimodal feature vectors and a knowledge base for code repair in failure processes, retrieve code repair case data;

[0008] When the key vector similarity between the code repair case data and the task execution failure pipeline is less than the target similarity threshold, the target repair code is generated based on the problem association data of the multimodal feature vectors and the code generation model.

[0009] According to another aspect of the present invention, an intelligent repair device for automated production line build errors is provided, comprising:

[0010] The feature vector acquisition module is used to acquire multimodal feature vectors of the failed pipeline when the target rule engine is unable to repair the failed pipeline code.

[0011] The repair case retrieval module is used to retrieve code repair case data based on multimodal feature vectors and the failure process code repair knowledge base.

[0012] The code generation module is used to generate target repair code based on the problem association data of multimodal feature vectors and the code generation model when the similarity between the code repair case data and the key vectors of the task execution failure pipeline is less than the target similarity threshold.

[0013] According to another aspect of the present invention, an electronic device is provided, the electronic device comprising:

[0014] At least one processor; and a memory communicatively connected to said at least one processor;

[0015] The memory stores a computer program that can be executed by the at least one processor, which is then executed by the at least one processor to enable the at least one processor to perform the intelligent repair method for automated pipeline construction errors as described in any embodiment of the present invention.

[0016] According to another aspect of the present invention, a computer-readable storage medium is provided, the computer-readable storage medium storing computer instructions for causing a processor to execute and implement the intelligent repair method for automated pipeline construction errors as described in any embodiment of the present invention.

[0017] According to another aspect of the present invention, a computer program product is provided, the computer program product comprising a computer program that, when executed by a processor, implements the intelligent repair method for automated pipeline construction errors as described in any embodiment of the present invention.

[0018] The technical solution of this invention, when a target rule engine cannot repair failed pipeline code, obtains the multimodal feature vector of the failed task execution pipeline. Based on the multimodal feature vector and a failed process code repair knowledge base, it retrieves code repair case data. Then, when the similarity between the code repair case data and the key vector of the failed task execution pipeline is less than a target similarity threshold, it generates target repair code based on the problem association data of the multimodal feature vector and a code generation model. This solution introduces a rule engine, a failed process code repair knowledge base, and an intelligent model to intelligently route and repair failed pipeline code, maximizing resource utilization. It can automatically, accurately, and intelligently diagnose the root causes of build failures, completely overcoming reliance on human experience and greatly improving the efficiency of software build problem repair. It solves the problems of existing automated pipeline build error repair heavily relying on manual labor and low error repair efficiency, breaking the strong dependence of automated pipeline build error repair on manual labor and significantly improving error repair efficiency.

[0019] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of the present invention, nor is it intended to limit the scope of the invention. Other features of the invention will become readily apparent from the following description. Attached Figure Description

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

[0021] Figure 1 A flowchart of an intelligent repair method for automated pipeline construction errors provided in Embodiment 1 of the present invention;

[0022] Figure 2 A flowchart of an intelligent repair method for automated pipeline construction errors provided in Embodiment 2 of the present invention;

[0023] Figure 3 A schematic diagram of the user interface for building an intelligent error correction system for automated production lines;

[0024] Figure 4 A schematic diagram illustrating the key steps in building an intelligent error correction method for automated production lines;

[0025] Figure 5 This is a schematic diagram of the structure of an intelligent repair device for automated production line construction errors provided in Embodiment 3 of the present invention;

[0026] Figure 6 A schematic diagram of an electronic device that can be used to implement embodiments of the present invention is shown. Detailed Implementation

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

[0028] It should be noted that the terms "target," etc., in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0029] Example 1

[0030] Figure 1 This is a flowchart illustrating an intelligent repair method for automated pipeline build errors provided in Embodiment 1 of the present invention. This embodiment is applicable to the automatic repair of automated pipeline build errors. The method can be executed by an intelligent repair device for automated pipeline build errors. This intelligent repair device can be implemented in hardware and / or software and can be configured in an electronic device. The electronic device may include, but is not limited to, servers or computers. Figure 1 As shown, the method includes:

[0031] Step 110: When the target rule engine is unable to repair the failed pipeline code, obtain the multimodal feature vector of the failed task execution pipeline.

[0032] The target rule engine can be a system that automates decision-making through predefined rules. The failure pipeline code can be the business code corresponding to a task execution failure pipeline. Multimodal feature vectors can be used to characterize the multi-dimensional feature vectors of the failure pipeline code. These multimodal feature vectors can include, but are not limited to, constructing log feature vectors and code context semantic feature vectors.

[0033] In this embodiment of the invention, after the CI / CD pipeline construction fails, the failed pipeline code can be repaired based on the target rule engine. If the target rule engine fails to repair the failed pipeline code, it indicates that the target rule engine cannot adapt the rules for repairing the failed pipeline code. The failed pipeline code is further parsed to obtain the multimodal feature vector of the task execution failure pipeline.

[0034] Step 120: Retrieve code repair case data based on multimodal feature vectors and the failure process code repair knowledge base.

[0035] The failure process code repair knowledge base can be a database of code repair cases from historical pipelines where tasks failed. The code repair case data can be related data on repair cases that are similar to those in the current failed task pipeline.

[0036] In this embodiment of the invention, code repair case data that are similar to the multimodal feature vector can be retrieved from the failed process code repair knowledge base.

[0037] Step 130: When the similarity between the code repair case data and the key vector of the task execution failure pipeline is less than the target similarity threshold, generate the target repair code based on the problem association data of the multimodal feature vector and the code generation model.

[0038] Key vector similarity can be used to characterize the similarity between the multimodal feature vectors of the pipeline corresponding to the code repair case data and the pipeline of task execution failure. The target similarity threshold can be a pre-set similarity threshold. Problem-related data can be relevant data about the problems that need to be repaired in the failed pipeline code. Problem-related data can include, but is not limited to, the encoding error log text of the failed pipeline code and the abstract syntax tree of the failed pipeline code. The code generation model can be a model capable of generating code to repair the failed pipeline. For example, the code generation model can be a Transformer model with an Encoder-Decoder structure. The target repair code can be used to repair problems in the failed pipeline code. The input Encoder part of the code generation model includes key log data and the abstract syntax tree of the failed pipeline code, and the output Decoder part generates a repaired code sequence or an editing script in an autoregressive manner.

[0039] In this embodiment of the invention, the similarity between code repair case data and task execution failure pipeline in terms of multimodal feature vectors can be determined, that is, the key vector similarity between code repair case data and task execution failure pipeline. If the key vector similarity between code repair case data and task execution failure pipeline is less than the target similarity threshold, the problem-related data corresponding to the multimodal feature vector is obtained, and the problem-related data is input into the code generation model to generate the target repair code.

[0040] Optionally, the model can be pre-trained on a large number of <error code, correct code> pairs and fine-tuned using a failure process code repair knowledge base to better suit the specific team's technology stack and coding style, thus obtaining a code generation model.

[0041] The technical solution of this invention, when a target rule engine cannot repair failed pipeline code, obtains the multimodal feature vector of the failed task execution pipeline. Based on the multimodal feature vector and a failed process code repair knowledge base, it retrieves code repair case data. Then, when the similarity between the code repair case data and the key vector of the failed task execution pipeline is less than a target similarity threshold, it generates target repair code based on the problem association data of the multimodal feature vector and a code generation model. This solution introduces a rule engine, a failed process code repair knowledge base, and an intelligent model to intelligently route and repair failed pipeline code, maximizing resource utilization. It can automatically, accurately, and intelligently diagnose the root causes of build failures, completely overcoming reliance on human experience and greatly improving the efficiency of software build problem repair. It solves the problems of existing automated pipeline build error repair heavily relying on manual labor and low error repair efficiency, breaking the strong dependence of automated pipeline build error repair on manual labor and significantly improving error repair efficiency.

[0042] Example 2

[0043] Figure 2 This is a flowchart of an intelligent repair method for automated pipeline construction errors provided in Embodiment 2 of the present invention. This embodiment is a specific embodiment based on the above embodiment, and provides specific optional implementation methods for obtaining the multimodal feature vectors of the pipeline that failed in task execution. Figure 2 As shown, the method includes:

[0044] Step 210: When the target rule engine is unable to repair the failed pipeline code, obtain the build logs of the continuous integration deployment process.

[0045] The continuous integration deployment process is also known as the CI / CD process. Build logs can be text files or data sets that record detailed operations and results of the build system (such as compilation, testing, packaging, etc.) during the software development process.

[0046] In this embodiment of the invention, when the target rule engine is unable to repair the failed pipeline code, the build logs corresponding to the continuous integration deployment process can be further obtained.

[0047] In an optional embodiment of the present invention, the intelligent repair method for automated pipeline construction errors may further include: determining the problem to be repaired in the failed pipeline code; matching the problem to be repaired with the rule base through a target rule engine to obtain the rule matching code, and repairing the code based on the rule matching code.

[0048] The issues to be fixed can be problems in the failed pipeline code that need to be corrected. These issues can include, but are not limited to, "ERROR", "FAILED", and "Exception". The rule matching code can be the code that the target rule engine matches from the rule base to resolve the issues to be fixed.

[0049] In this embodiment of the invention, the problem to be repaired in the failed pipeline code can be determined first, and then the problem to be repaired can be matched with the rule base through the target rule engine. Then, the repair code corresponding to the successfully matched rule can be used as the rule matching code, and the failed pipeline code can be repaired through the rule matching code.

[0050] In an optional embodiment of the present invention, code repair based on rule matching codes may include: evaluating the priority of rule matching codes when rule matching codes are not unique; determining the target repair code based on the priority of the rule matching codes; and performing code repair based on the target repair code.

[0051] In this embodiment of the invention, if the rule matching code matched by the target rule engine is not unique, the priority of the rule matching code matched by the target rule engine is determined based on the preset rule matching code priority evaluation rule, and then the rule matching code with the highest priority is used as the target repair code, so as to repair the code through the target repair code.

[0052] For example, the rules in the rule base use the <condition, action, priority> triple. The condition part is a logical expression written in a domain-specific language, which can be used to make joint judgments on multimodal information.

[0053] For example, a rule in the rule base can be in the following form:

[0054] IF

[0055] (error_type == "CompilationError") AND

[0056] (error_message MATCHES "expected ';'")AND

[0057] (code_context.ast_at_line IS "Statement")

[0058] THEN

[0059] action=GeneratePatch(operation: "INSERT", line: target_line,position: "END", content:";")

[0060] priority=100

[0061] The priorities of the condition part, the action part (i.e., the rule matching code), and the rule matching code are as follows: (error_type=="CompilationError")AND(error_message MATCHES "expected';'")AND(code_context.ast_at_line IS "Statement"); action=GeneratePatch(operation: "INSERT", line: target_line, position: "END", content: ";"); priority=100.

[0062] For example, the more ANDs in the condition section, the higher the priority of the rule.

[0063] Step 220: Extract key log data from the build log and extract the code attribute abstraction graph of the failed pipeline code.

[0064] Key log data can be error traceability entities extracted from build logs. Key log data can include, but is not limited to, error types, file paths (supporting absolute and relative paths), line numbers, dependency package names, and undefined symbol names. The code attribute abstraction graph can be a graphical representation model that integrates code structure and attribute information. The code attribute abstraction graph is used to overlay the abstract syntax tree, control flow graph, and program dependency graph onto a single graph structure.

[0065] In this embodiment of the invention, a neural network model based on an attention mechanism can be used to perform hierarchical parsing of the build log. First, the macro structure of the build log (such as the compilation stage and the testing stage) can be identified. Then, specific error stacks can be located within each stage, and named entity recognition can be performed on the error stacks to obtain key log data. Furthermore, semantic representation of the code context can be performed based on the failed pipeline code, which can be abstracted into a code attribute abstract graph.

[0066] Step 230: Based on key log data and code attribute abstraction diagram, determine the multimodal feature vector of the task execution failure pipeline.

[0067] In this embodiment of the invention, key log data, code attribute abstract graph, and data snapshots composed of key log data and code attribute abstract graph can be used as multimodal feature vectors of the task execution failure pipeline.

[0068] Step 240: Retrieve code repair case data based on multimodal feature vectors and the failure process code repair knowledge base.

[0069] In an optional embodiment of the present invention, retrieving code repair case data based on multimodal feature vectors and a failure process code repair knowledge base may include: retrieving the failure process code repair knowledge base based on multimodal feature vectors, using an approximate nearest neighbor search algorithm and vector retrieval technology, to obtain code repair case data.

[0070] Vector retrieval techniques may include, but are not limited to, the HNSW (Hierarchical Navigable SmallWorld) algorithm.

[0071] In this embodiment of the invention, the multimodal feature vectors can be matched and retrieved with the repair cases in the failure process code repair knowledge base based on the approximate nearest neighbor search algorithm and vector retrieval technology to obtain code repair case data.

[0072] Step 250: When the similarity between the code repair case data and the key vector of the task execution failure pipeline is less than the target similarity threshold, generate the target repair code based on the problem association data of the multimodal feature vector and the code generation model.

[0073] In an optional embodiment of the present invention, after retrieving the code repair knowledge base of the failed process based on multimodal feature vectors, according to the approximate nearest neighbor search algorithm and vector retrieval technology, and obtaining code repair case data, the method may further include: when the similarity between the code repair case data and the key vector of the task execution failure pipeline is greater than the target similarity threshold, determining the target repair code based on the code repair case data and the case repair association attributes.

[0074] Among them, the case repair association attribute can be used to characterize the repair selection weight of the repair case. The case repair association attribute may include, but is not limited to, the repair case confidence weight, the repair case repair success rate weight, and the code complexity weight.

[0075] In this embodiment of the invention, if the similarity between the code repair case data and the key vector of the task execution failure pipeline is greater than the target similarity threshold, the code repair case data is sorted by fit based on the case repair association attribute to further filter the code repair case data, thereby selecting the repair code corresponding to the code repair case data with the highest fit as the target repair code.

[0076] For example, a meta-learner is used to comprehensively score code repair case data. The comprehensive score = repair case confidence weight × repair case confidence + repair case success rate weight × repair case historical success rate + code complexity weight × (1 - code complexity). Finally, the solution with the highest comprehensive score is recommended to the user, realizing intelligent decision-making of "rules first, artificial intelligence model supplement, and selection of the best".

[0077] In an optional embodiment of the present invention, after generating the target repair code based on the problem association data of the multimodal feature vector and the code generation model, the method may further include: obtaining user feedback data on the code repair of the target repair code; and updating the case repair association attributes based on the code repair feedback data.

[0078] Among them, code fix feedback data can be used to reflect how users apply the target fix code.

[0079] In this embodiment of the invention, user feedback data on code repair for the target repair code can be collected, and then, based on the feedback data on code repair for the target repair code, the case repair association attributes of the corresponding repair case or the priority of the rule-matching code can be dynamically adjusted.

[0080] Optionally, if the feedback data for the code repair of the target code indicates that the user accepted the repair and the recognition was successfully built, the case repair association attribute of that repair case will be improved, i.e., the repair case confidence weight and repair case success rate weight will be increased. If the feedback data for the code repair of the target code indicates that the user accepted the repair and the recognition was rebuilt, the case repair association attribute of that repair case will be decreased, i.e., the repair case confidence weight and repair case success rate weight will be decreased. If the feedback data for the code repair of the target code indicates that the user rejected the repair and manually repaired it, the repair case confidence weight and repair case success rate weight will be decreased, but the decrease will be less than the decrease when the user accepted the repair and the recognition was rebuilt.

[0081] Optionally, an intelligent repair system for automated pipeline build errors may include a CI / CD platform, a multimodal awareness layer, a hybrid intelligent decision-making layer, a knowledge management layer, an interactive execution layer, and a reinforcement learning feedback layer. The CI / CD platform can trigger webhook events and transmit build logs / metadata. The multimodal awareness layer can perform event listening (such as webhook reception, event deduplication, and queue management), log analysis (such as error identification, entity identification, semantic encoding, etc.), and code context extraction (abstract syntax tree analysis, graph embedding, dependency analysis). The hybrid intelligent decision-making layer includes a target rule engine and an intelligent model. The knowledge management layer includes a failure process code repair knowledge base, a vector knowledge base, and a quality evaluator. The quality evaluator is used for tracking the effectiveness of code repair case data and performing confidence correction. The interactive execution layer includes a user interface and a solution executor. The solution executor can create and execute repair branches for the target repair code and can also trigger new builds. The user interface can be found in [reference needed]. Figure 3 .

[0082] In a specific example, intelligent error correction methods for automated pipeline builds include, for example: Figure 4 The key steps, as shown, include: activating multimodal perception after the CI / CD pipeline fails, generating multimodal feature vectors, and then performing hybrid intelligent decision-making layer analysis. One approach determines the repair code based on a target rule engine, while the other approach determines the repair code based on an intelligent model. The repair codes are further optimized and ranked, with the highest priority or highest-scoring repair code selected as the target repair code and executed. After executing the target repair code, the repair results are verified. If the result is positive, incremental learning is performed; if the result is negative, the case repair association attributes are adjusted.

[0083] A neural network model based on an attention mechanism is used to perform hierarchical parsing of the construction logs to obtain key log data. After acquiring the failed pipeline code, code attribute graphs are abstracted to obtain code attribute abstract graphs. Using code pre-trained models such as CodeBERT or Tree-SSTM, code fragments are converted into high-dimensional semantic vectors. These vectors can capture the syntactic and semantic information of the code, such as "userDao is a variable not declared in the current class." Furthermore, the key log data and the code attribute abstract graphs are combined to form a comprehensive "snapshot of the failure scene."

[0084] The target rule engine within the hybrid intelligence-based dual-path analysis engine employs a highly efficient pattern matching algorithm, enabling evaluation of all rules within milliseconds, even with a massive rule base. The AI ​​service model within this engine can use the multimodal feature vectors of currently failing pipeline code as query keywords, performing approximate nearest neighbor searches within the failed process code repair knowledge base. For example, a high-performance vector retrieval library can be used to achieve millisecond-level retrieval across hundreds of millions of cases. The results returned by the AI ​​service model not only include similar cases but also key vector similarity, providing a basis for subsequent decision-making. If the search results are unsatisfactory (e.g., the highest key vector similarity < 0.8), the code generation model is activated.

[0085] The construction method of the failure process code repair knowledge base directly affects the system's intelligence level. Vectorized storage: The multimodal feature vector of each repair case is stored together with the original structured data. This enables semantic similarity-based retrieval. Furthermore, this solution can automatically assign a quality label to each repair case. For example, a solution that is frequently accepted by users and successfully rebuilt after repair will have a higher quality score. During the training and retrieval of the AI ​​service model, high-quality cases will be prioritized to ensure that the system "learns" best practices.

[0086] The key to making intelligent bug fixing in automated pipelines go from "easy to use" to "smart" lies in the reinforcement learning cycle. This involves evaluating the reward score of the target bug fix code while simultaneously using correct actions (manual solutions) as new samples for learning. This allows the system to not only accumulate new cases but also dynamically adjust its decision-making strategies. For example, if a generated target bug fix type is frequently rejected by users, the weight of its bug fix-related attributes will decrease; conversely, if an efficient rule is frequently used, its priority may be automatically increased by the system.

[0087] This solution reduces the average fault repair time from hours to minutes, decreases developer intervention by 80%, seamlessly integrates workflows, and allows developers to confirm repairs with a single click without switching tool contexts. It also features continuous learning capabilities, automated knowledge accumulation, and intelligent rule evolution.

[0088] The technical solution of this invention involves obtaining build logs from the continuous integration deployment process when a target rule engine cannot repair failed pipeline code. Key log data is extracted from these build logs, and a code attribute abstraction graph of the failed pipeline code is extracted. Based on the key log data and the code attribute abstraction graph, a multimodal feature vector of the failed pipeline is determined. Then, based on the multimodal feature vector and a failed process code repair knowledge base, code repair case data is retrieved. When the similarity between the code repair case data and the key vector of the failed pipeline is less than a target similarity threshold, target repair code is generated based on the problem association data of the multimodal feature vector and a code generation model. This solution introduces a rule engine, a knowledge base for repairing failed pipeline code, and an intelligent model to intelligently route and repair failed pipeline code, maximizing resource utilization. Furthermore, the knowledge base and intelligent model possess continuous learning capabilities, automated knowledge accumulation, and intelligent rule evolution capabilities, enabling automatic, accurate, and intelligent diagnosis of the root causes of build failures. This completely overcomes reliance on human experience, significantly improving the efficiency of software build problem repair. It solves the problems of existing automated pipeline build error repair being heavily reliant on manual intervention and having low efficiency. This solution breaks the strong dependence of automated pipeline build error repair on human intervention and greatly improves error repair efficiency.

[0089] Example 3

[0090] Figure 5 This is a schematic diagram of the structure of an intelligent repair device for automated production line errors provided in Embodiment 3 of the present invention. Figure 5 As shown, the device includes:

[0091] The feature vector acquisition module 310 is used to acquire the multimodal feature vector of the task execution failure pipeline when the failure pipeline code cannot be repaired based on the target rule engine.

[0092] The repair case retrieval module 320 is used to retrieve code repair case data based on multimodal feature vectors and the failure process code repair knowledge base;

[0093] The code generation module 330 is used to generate target repair code based on the problem association data of multimodal feature vectors and the code generation model when the similarity between the code repair case data and the key vector of the task execution failure pipeline is less than the target similarity threshold.

[0094] The technical solution of this invention, when a target rule engine cannot repair failed pipeline code, obtains the multimodal feature vector of the failed task execution pipeline. Based on the multimodal feature vector and a failed process code repair knowledge base, it retrieves code repair case data. Then, when the similarity between the code repair case data and the key vector of the failed task execution pipeline is less than a target similarity threshold, it generates target repair code based on the problem association data of the multimodal feature vector and a code generation model. This solution introduces a rule engine, a failed process code repair knowledge base, and an intelligent model to intelligently route and repair failed pipeline code, maximizing resource utilization. Furthermore, the failed process code repair knowledge base and intelligent model possess continuous learning capabilities, automated knowledge accumulation, and intelligent rule evolution capabilities, enabling automatic, accurate, and intelligent diagnosis of the root causes of construction failures. This completely overcomes the dependence on human experience, greatly improving the efficiency of software construction problem repair. It solves the problems of existing automated pipeline construction error repair heavily relying on manual labor and low error repair efficiency, breaking the strong dependence of automated pipeline construction error repair on manual labor and significantly improving error repair efficiency.

[0095] Optionally, the intelligent repair device for automated pipeline construction errors also includes a rule engine repair module, used to determine the problems to be repaired in the failed pipeline code; through the target rule engine, the problems to be repaired are matched with the rule base to obtain rule matching code, and code repair is performed based on the rule matching code.

[0096] Optionally, the rule engine repair module is used to evaluate the priority of the rule matching code when the rule matching code is not unique; determine the target repair code according to the priority of the rule matching code; and perform code repair based on the target repair code.

[0097] Optionally, the feature vector acquisition module 310 is used to acquire the build log of the continuous integration deployment process; extract key log data from the build log and extract the code attribute abstract graph of the failed pipeline code; and determine the multimodal feature vector of the task execution failure pipeline based on the key log data and the code attribute abstract graph.

[0098] Optionally, the repair case retrieval module 320 is used to retrieve code repair case data from the failure process code repair knowledge base based on the multimodal feature vectors, using an approximate nearest neighbor search algorithm and vector retrieval technology.

[0099] Optionally, the code generation module 330 is used to determine the target repair code based on the code repair case data and the case repair association attributes when the similarity between the code repair case data and the key vector of the task execution failure pipeline is greater than the target similarity threshold.

[0100] Optionally, the intelligent repair device for automated pipeline construction errors also includes a self-learning module for acquiring user feedback data on the target repair code; and updating the case repair association attributes based on the code repair feedback data.

[0101] The intelligent repair device for automated pipeline construction errors provided in this embodiment of the invention can execute the intelligent repair method for automated pipeline construction errors provided in any embodiment of the invention, and has the corresponding functional modules and beneficial effects of the method execution.

[0102] Example 4

[0103] Figure 6 A schematic diagram of an electronic device that can be used to implement embodiments of the present invention is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital assistants and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the invention described and / or claimed herein.

[0104] like Figure 6 As shown, the electronic device 10 includes at least one processor 11 and a memory, such as ROM 12, RAM 13, etc., communicatively connected to the at least one processor 11. The memory stores computer programs executable by the at least one processor. The processor 11 can perform various appropriate actions and processes based on the computer program stored in the ROM 12 or loaded into the RAM 13 from the storage unit 18. The RAM 13 can also store various programs and data required for the operation of the electronic device 10. The processor 11, ROM 12, and RAM 13 are interconnected via a bus 14. An I / O interface 15 is also connected to the bus 14. The ROM 12 is a read-only memory, the RAM 13 is a random access memory, and the I / O interface 15 is an input / output interface.

[0105] Multiple components in electronic device 10 are connected to I / O interface 15, including: input unit 16, such as keyboard, mouse, etc.; output unit 17, such as various types of displays, speakers, etc.; storage unit 18, such as disk, optical disk, etc.; and communication unit 19, such as network card, modem, wireless transceiver, etc. Communication unit 19 allows electronic device 10 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0106] Processor 11 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of processor 11 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various processors running machine learning model algorithms, digital signal processors (DSPs), and any suitable processor, controller, microcontroller, etc. Processor 11 performs the various methods and processes described above, such as intelligent repair methods for automated pipeline construction errors.

[0107] In some embodiments, the intelligent repair method for automated pipeline build errors can be implemented as a computer program tangibly contained in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program can be loaded and / or installed on electronic device 10 via ROM 12 and / or communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the intelligent repair method for automated pipeline build errors described above can be performed. Alternatively, in other embodiments, processor 11 can be configured to perform the intelligent repair method for automated pipeline build errors by any other suitable means (e.g., by means of firmware).

[0108] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0109] Computer programs used to implement the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, such that when executed by the processor, the computer programs cause the functions / operations specified in the flowcharts and / or block diagrams to be performed. The computer programs may be executed entirely on a machine, partially on a machine, or as a standalone software package, partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0110] In the context of this invention, a computer-readable storage medium can be a tangible medium that may contain or store a computer program for use by or in conjunction with an instruction execution system, apparatus, or device. A computer-readable storage medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. Alternatively, a computer-readable storage medium may be a machine-readable signal medium. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, RAM, ROM, erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0111] To provide interaction with a user, the systems and techniques described herein can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the electronic device. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0112] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or middleware components (e.g., application servers), or frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), blockchain networks, and the Internet.

[0113] A computing system can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and VPS servers, such as high management difficulty and weak business scalability.

[0114] This application also discloses a computer program product, which includes a computer program that, when executed by a processor, implements the intelligent repair method for automated pipeline construction errors provided in any embodiment of this application. This program product shares the same inventive concept as the intelligent repair method for automated pipeline construction errors disclosed in the embodiments of this application, and therefore will not be described further here.

[0115] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this invention can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this invention can be achieved, and this is not limited herein.

[0116] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. A method for intelligently repairing errors in the construction of an automated production line, characterized in that, include: When the target rule engine is unable to repair the failed pipeline code, obtain the multimodal feature vector of the failed task execution pipeline; Based on the multimodal feature vectors and the failure process code repair knowledge base, retrieve code repair case data; When the similarity between the code repair case data and the key vector of the task execution failure pipeline is less than the target similarity threshold, the target repair code is generated based on the problem association data of the multimodal feature vector and the code generation model.

2. The method according to claim 1, characterized in that, Also includes: Identify the issues to be fixed in the failed pipeline code; The target rule engine matches the problem to be fixed with the rule base to obtain the rule matching code, and then the code is fixed based on the rule matching code.

3. The method according to claim 2, characterized in that, Code repair is performed based on the rules and matching codes, including: When the rule matching code is not unique, the priority of the rule matching code is evaluated; Based on the priority of the matching code according to the rules, the target repair code is determined, and code repair is performed based on the target repair code.

4. The method according to claim 1, characterized in that, Obtain the multimodal feature vectors of the task execution failure pipeline, including: Obtain build logs from the continuous integration deployment process; Extract key log data from the construction log and extract the code attribute abstraction graph of the failed pipeline code; Based on the key log data and the code attribute abstraction graph, the multimodal feature vector of the task execution failure pipeline is determined.

5. The method according to claim 1, characterized in that, Based on the aforementioned multimodal feature vectors and the failure process code repair knowledge base, code repair case data is retrieved, including: Based on the multimodal feature vectors, the failure process code repair knowledge base is retrieved using the approximate nearest neighbor search algorithm and vector retrieval technology to obtain code repair case data.

6. The method according to claim 5, characterized in that, After retrieving code repair case data from the failed process code repair knowledge base based on the multimodal feature vectors using an approximate nearest neighbor search algorithm and vector retrieval technology, the process further includes: When the similarity between the code repair case data and the key vector of the task execution failure pipeline is greater than the target similarity threshold, the target repair code is determined based on the code repair case data and the case repair association attributes.

7. The method according to claim 5, characterized in that, After generating the target repair code based on the problem-related data and code generation model using the multimodal feature vectors, the process also includes: Obtain user feedback data on code fixes for the target code; Based on the feedback data from code fixes, the case was updated to fix related attributes.

8. An electronic device, characterized in that, The electronic device includes: At least one processor, and a memory communicatively connected to said at least one processor; The memory stores a computer program that can be executed by the at least one processor, which enables the at least one processor to perform the intelligent repair method for automated pipeline construction errors as described in any one of claims 1-7.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions that, when executed by a processor, implement the intelligent repair method for automated pipeline construction errors as described in any one of claims 1-7.

10. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements an intelligent repair method for automated pipeline construction errors according to any one of claims 1-7.

Images