A method, device and equipment for concurrent execution of multi-algorithm nodes of a training task

Abstract

The application discloses a kind of multi-algorithm node concurrent execution methods, apparatus and equipment of training task, the method includes: in response to breeding model training request, generating the training task matrix and preprocessing cache key corresponding to breeding model training request;Determine the multiple branch format conversion nodes and multiple algorithm nodes corresponding to training task matrix, and the dependency between multiple branch format conversion nodes and multiple algorithm nodes;Based on the preprocessing cache key, obtain the preprocessing result meeting the consistency condition from the preset cache, and input the preprocessing result to the corresponding branch format conversion node;In the case where the corresponding branch format conversion node completes the conversion to preprocessing result, based on the dependency, the preset resource image of each algorithm node and the available resource data obtained determine multiple concurrent nodes in multiple algorithm nodes, and execute multiple concurrent nodes, can avoid the waste of computing power expenditure and improve the rationality of resource scheduling.

Description

Technical Field

[0001] This application belongs to the field of electronic digital data processing technology, specifically relating to a method, apparatus, and device for concurrent execution of multiple algorithm nodes in a training task. Background Technology

[0002] With the rapid development of digital analysis in breeding, the scale and processing complexity of breeding data continue to grow. To compare the predictive performance of different breeding models, it is necessary to perform combined training on the same breeding model with multiple phenotypic traits and algorithm combinations by executing different algorithm nodes. Therefore, how to efficiently and rationally execute multiple algorithm nodes has become a pressing technical problem to be solved in this field.

[0003] In existing technologies, the execution method of multiple algorithm nodes mainly involves creating a complete combination task for each phenotype and algorithm combination, preprocessing each combination task, and then sequentially assigning the preprocessed tasks to the corresponding algorithm nodes. Each algorithm node executes the tasks in the order they are received, with only one algorithm node executing at a time. However, existing technologies require the repeated execution of a large number of preprocessing operations, and different algorithms have different resource requirements, resulting in serious waste of redundant computing power and unreasonable resource scheduling for multiple algorithm node execution. Summary of the Invention

[0004] This application provides a method, apparatus, and device for concurrent execution of multiple algorithm nodes in training tasks, which solves the problems of serious waste of redundant computing power and unreasonable resource scheduling for multiple algorithm node execution in the prior art. By generating a training task matrix and a preprocessing cache key corresponding to the breeding model training request, and obtaining preprocessing results that meet the consistency conditions from the preset cache based on the preprocessing cache key, and inputting the preprocessing results to the corresponding branch format conversion node, the purpose of reusing preprocessing results can be achieved, avoiding the waste of computing power caused by repeated preprocessing. Furthermore, by concurrently executing multiple algorithm nodes based on the inter-node dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, the rationality of resource scheduling for multiple algorithm node execution is improved.

[0005] In a first aspect, embodiments of this application provide a method for concurrent execution of multiple algorithm nodes in a training task, the method comprising: In response to a breeding model training request, a training task matrix and a preprocessing cache key corresponding to the breeding model training request are generated; Determine the multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependencies between the multiple branch format conversion nodes and multiple algorithm nodes; Based on the preprocessing cache key, the preprocessing result that meets the consistency condition is obtained from the preset cache, and the preprocessing result is input to the corresponding branch format conversion node; Once the preprocessing result conversion is completed at the corresponding branch format conversion node, multiple concurrent nodes are determined based on dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, and these multiple concurrent nodes are executed.

[0006] Secondly, embodiments of this application provide a multi-algorithm node concurrent execution device for a training task, the device comprising: The training task generation module is used to generate a training task matrix and preprocessing cache key corresponding to the breeding model training request in response to the breeding model training request. The dependency determination module is used to determine multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependencies between the multiple branch format conversion nodes and the multiple algorithm nodes. The preprocessing module is used to obtain the preprocessing result that meets the consistency condition from the preset cache based on the preprocessing cache key, and input the preprocessing result into the corresponding branch format conversion node; The concurrent execution module is used to determine multiple concurrent nodes among multiple algorithm nodes based on dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, after the preprocessing result transformation is completed at the corresponding branch format conversion node, and to execute multiple concurrent nodes.

[0007] Thirdly, embodiments of this application provide an electronic device including a processor, a memory, and a program or instructions stored in the memory and executable on the processor, wherein the program or instructions, when executed by the processor, implement the steps of the method described in the first aspect.

[0008] Fourthly, embodiments of this application provide a readable storage medium on which a program or instructions are stored, which, when executed by a processor, implement the steps of the method described in the first aspect.

[0009] Fifthly, embodiments of this application also provide a computer program product comprising a computer program stored in a computer-readable storage medium, wherein at least one processor of the device reads from the computer-readable storage medium and executes the computer program, causing the device to perform the method described in the first aspect.

[0010] In this embodiment, in response to a breeding model training request, a training task matrix and a preprocessing cache key corresponding to the breeding model training request are generated; multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix are determined, as well as the dependencies between the multiple branch format conversion nodes and the multiple algorithm nodes; preprocessing results that meet the consistency conditions are obtained from a preset cache based on the preprocessing cache key, and the preprocessing results are input to the corresponding branch format conversion node; when the corresponding branch format conversion node completes the conversion of the preprocessing results, multiple concurrent nodes among the multiple algorithm nodes are determined based on the dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, and the multiple concurrent nodes are executed. The multi-algorithm node concurrent execution method described above solves the problems of serious waste of redundant computing power and unreasonable resource scheduling of multi-algorithm node execution in the existing technology. By generating a training task matrix and a preprocessing cache key corresponding to the breeding model training request, and obtaining preprocessing results that meet the consistency conditions from the preset cache based on the preprocessing cache key, and inputting the preprocessing results to the corresponding branch format conversion node, the purpose of reusing preprocessing results can be achieved, avoiding the waste of computing power caused by repeated preprocessing. Furthermore, by executing multiple algorithm nodes concurrently based on the inter-node dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, the rationality of resource scheduling for multi-algorithm node execution is improved. Attached Figure Description

[0011] Figure 1 This is a flowchart of a method for concurrent execution of multiple algorithm nodes in a training task, provided in an embodiment of this application. Figure 2 This is a flowchart of a method for generating preprocessed cache keys provided in an embodiment of this application; Figure 3 This is a flowchart of a node dependency determination method provided in an embodiment of this application; Figure 4 This is a multi-node dependent directed acyclic graph provided in the embodiments of this application; Figure 5 This is a flowchart of a multi-node-based task processing method provided in an embodiment of this application; Figure 6 This is a structural block diagram of a multi-algorithm node concurrent execution device for a training task provided in an embodiment of this application; Figure 7 This is a schematic diagram of the structure of a multi-algorithm node concurrent execution device for a training task provided in an embodiment of this application. Detailed Implementation

[0012] To make the objectives, technical solutions, and advantages of this application clearer, specific embodiments of this application will be described in further detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are merely for explaining this application and not for limiting it. It should also be noted that, for ease of description, only the parts relevant to this application are shown in the drawings, not all of them. Before discussing exemplary embodiments in more detail, it should be mentioned that some exemplary embodiments are described as processes or methods depicted as flowcharts. Although the flowcharts describe operations (or steps) as sequential processes, many of these operations can be performed in parallel, concurrently, or simultaneously. Furthermore, the order of the operations can be rearranged. The process can be terminated when its operation is completed, but may also have additional steps not included in the drawings. The process can correspond to a method, function, procedure, subroutine, subprogram, etc.

[0013] The technical solutions of the embodiments of this application will be clearly described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this application. All other embodiments obtained by those skilled in the art based on the embodiments of this application are within the scope of protection of this application.

[0014] The terms "first," "second," etc., used in the specification and claims of this application are used to distinguish similar objects and not to describe a specific order or sequence. It should be understood that such use of data can be interchanged where appropriate so that embodiments of this application can be implemented in orders other than those illustrated or described herein, and the objects distinguished by "first," "second," etc., are generally of the same class and the number of objects is not limited; for example, a first object can be one or more. Furthermore, in the specification and claims, "and / or" indicates at least one of the connected objects, and the character " / " generally indicates that the preceding and following objects are in an "or" relationship.

[0015] First, this solution can be used in scenarios involving multi-algorithm and multi-phenotype combination training in digital analysis of breeding, especially for scenarios where the same genotype data needs to be combined with multiple phenotypic traits and multiple algorithms for training simultaneously, and where multiple algorithm nodes need to be executed concurrently to shorten the overall training cycle. By generating a training task matrix and a preprocessing cache key corresponding to the breeding model training request, and obtaining preprocessing results that meet the consistency conditions from the preset cache based on the preprocessing cache key, and inputting the preprocessing results to the corresponding branch format conversion node, the purpose of reusing preprocessing results can be achieved, avoiding the waste of computing power caused by repeated preprocessing. Furthermore, by executing multiple algorithm nodes concurrently based on the dependencies between nodes, the preset resource profiles of each algorithm node, and the obtained available resource data, the rationality of resource scheduling for multi-algorithm node execution is improved. Based on the above application scenarios, it can be understood that the execution subject of each step in this solution can be a computer device. This computer device refers to any electronic device with data computing, processing, and storage capabilities, such as a PC (Personal Computer) or other terminal devices, or a server or other devices. This application embodiment does not limit this.

[0016] The following description, in conjunction with the accompanying drawings, details a method, apparatus, and device for concurrent execution of multiple algorithm nodes in a training task provided by this application, through specific embodiments and application scenarios.

[0017] Figure 1 This is a flowchart illustrating a method for concurrent execution of multiple algorithm nodes in a training task, as provided in an embodiment of this application. Figure 1 As shown, the specific steps include the following: S101, in response to the breeding model training request, generates a training task matrix and preprocessing cache key corresponding to the breeding model training request.

[0018] The breeding model training request can be user-submitted instruction data received through a preset interactive interface to initiate a multi-algorithm training process. The breeding model training request includes at least the genotype file to be analyzed, the set of phenotypic traits to be analyzed, the set of algorithms to be executed, and quality control parameters and software version information for controlling the data processing. The training task matrix can be a two-dimensional task list formed by pairwise combinations of phenotypic traits and algorithms in the breeding model training request. Each element in the matrix represents an independent training task, i.e., a combination of a specific phenotypic trait and a specific algorithm. If the request contains M phenotypic traits and N algorithms, the training task matrix has a size of M×N, and each element in the matrix corresponds to an algorithm node to be executed. The training task matrix is ​​used to determine the number of algorithm nodes to be generated subsequently and the phenotypic and algorithm combination relationship corresponding to each algorithm node. The preprocessing cache key can be a string used to uniquely identify a preprocessing operation and its output result. The key is generated based on the file content summary of the genotype file, quality control parameters, and preprocessing software version. The file content summary is obtained by hashing the genotype file. Quality control parameters include at least the MAF (Minor Allele Frequency) threshold and the missing rate threshold. Preprocessing software versions include at least PLINK (genotype data analysis toolset) and Beagle (genotype imputation software). The same genotype file content, quality control parameters, and software version will generate the same preprocessing cache key. This key is used to subsequently retrieve reusable historical preprocessing results from the preset cache. The genotype file can be a file recording genotype data of an individual at multiple genetic loci in breeding digitization analysis. It is the original input data for all preprocessing operations in this scheme (including quality control filtering, genotype imputation, and index generation) and one of the core objects used to generate the preprocessing cache key.

[0019] It should be noted that this scheme involves file content summary values, preset product summary values, and actual summary values ​​of preprocessing results. The file content summary value is obtained by hashing the genotype file and is used to generate the preprocessing cache key along with quality control parameters, software version, and other information. The preset product summary value is obtained by hashing the preprocessing result data file when the preprocessing result is first generated and saved to the preset cache. It is used to perform consistency checks on the actual summary value of the preprocessing result when the preprocessing cache key cache is hit, to verify whether the reused preprocessing result is complete and has not been tampered with. The preprocessing result can be a set of data files obtained after performing common preprocessing operations on the genotype files in the breeding model training request. This set of data files serves as input data for subsequent branch format conversion nodes. The actual summary value of the preprocessing result is the summary value obtained by hashing the preprocessing result data files stored in the preset cache during the consistency check process. When the preset cache is hit, the actual digest value of the preprocessed result corresponding to the preprocessed cache key can be compared with the preset product digest value associated with the first storage of the preprocessed result. If the actual digest value is consistent with the preset product digest value, the preprocessed result is confirmed to be complete and unaltered, and the consistency check is passed.

[0020] In one embodiment, the specific method for generating the training task matrix and preprocessing cache key corresponding to the breeding model training request in response to the breeding model training request can be as follows: Upon receiving the breeding model training request, verify the legality of the request, confirm that the data file paths it carries are accessible and in the correct format, extract metadata from the breeding model training request to identify the training scope, i.e., which phenotypic traits and which algorithms need to participate in training, and construct a task index table containing all phenotypic and algorithm combinations in memory based on the extracted metadata. This task index table is arranged with phenotypic rows and algorithm columns, and each cell records a set of phenotypic and algorithm combinations to be executed and their corresponding file path mappings. While completing the task index table, read the genotype data file in the current request, input the entire data content of the file into a hash function to calculate the file content summary, obtain the quality control parameter values ​​carried in the request and the PLINK and Beagle versions on which preprocessing depends, concatenate the file content summary, quality control parameters, PLINK version, and Beagle version in the order of a preset delimiter, perform a hash operation on the whole, and use the resulting hash value as the preprocessing cache key.

[0021] S102, determine the multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependencies between the multiple branch format conversion nodes and the multiple algorithm nodes.

[0022] In this scheme, the branch format conversion node can be a computational node that converts the unified preprocessing product into the corresponding format based on the branch to which the algorithm node belongs. Different algorithm nodes have different requirements for the input data format. The branch format conversion nodes in this scheme include R branches and GS branches. The R branch is the format conversion branch corresponding to R language algorithms (such as rrBLUP, Random Forest), which requires PLINK raw format; the GS branch is the format conversion branch corresponding to Python deep learning algorithms, which requires matrix CSV format. That is, the R branch format conversion node is used to convert the raw input data into PLINK raw format data, and the GS branch format conversion node is used to convert the raw input data into matrix CSV format data. The algorithm node can be a computational node used to perform training tasks of a single phenotypic trait and a single algorithm combination. The algorithm nodes correspond one-to-one with the training tasks in the training task matrix, and each algorithm node is responsible for training a breeding model with a specific phenotypic trait and a specific algorithm combination. The number of algorithm nodes depends on the total number of phenotypic trait and algorithm combinations in the training task matrix. If there are M phenotypic traits and N algorithms, then the number of algorithm nodes is M×N. Dependencies can be constraints used to characterize the execution order between branch format conversion nodes and algorithm nodes. In this scheme, dependencies can be represented by constructing a directed acyclic graph (DAG) between nodes. A dependency indicates that the execution of one computation node depends on the completion of another. In this scheme, the dependency is specifically manifested in the fact that algorithm nodes depend on branch format conversion nodes; that is, branch format conversion nodes must execute before algorithm nodes, and algorithm nodes can only begin execution after the branch format conversion nodes have produced their format conversion results.

[0023] In one embodiment, the specific method for determining multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependencies between the multiple branch format conversion nodes and multiple algorithm nodes, can be as follows: traverse each training task in the training task matrix, obtain the algorithm identifier corresponding to each training task, query a preset algorithm branch mapping table based on the algorithm identifier, determine the branch type to which the algorithm belongs, group all algorithm nodes belonging to the same branch type together, generate a branch format conversion node for each group, and obtain multiple branch format conversion nodes corresponding to the training task matrix. Simultaneously, generate an algorithm node for each training task in the training task matrix, and obtain multiple algorithm nodes corresponding to the training task matrix. Based on the branch type to which each algorithm node belongs, associate the algorithm node with the branch format conversion node of the corresponding branch, making the branch format conversion node the predecessor node of the algorithm node, forming a dependency relationship where multiple algorithm nodes depend on multiple branch format conversion nodes. Optionally, the branch format conversion nodes and algorithm nodes can also be treated as computation nodes in a directed acyclic graph (DAG), with the dependencies as directed edges, and a DAG can be constructed according to the direction from the branch format conversion nodes to the algorithm nodes.

[0024] S103, based on the preprocessing cache key, obtain the preprocessing result that meets the consistency condition from the preset cache, and input the preprocessing result to the corresponding branch format conversion node.

[0025] The preprocessing results can be a set of data files obtained by performing common preprocessing operations on the genotype files in the breeding model training request. Preprocessing operations include at least one of the following: quality control filtering of genotype data, imputation of missing genotypes, and generation of index files for downstream tools. The preprocessing results contain the imputed genotype data files and their accompanying auxiliary files, which together form the data foundation for subsequent branch format conversion operations. The preprocessing results are stored in a preset cache using a preprocessing cache key as an index, allowing them to be reused by training requests with the same preprocessing cache key.

[0026] In one embodiment, the specific method for retrieving a preprocessing result that meets the consistency condition from a preset cache based on a preprocessing cache key and inputting the preprocessing result to the corresponding branch format conversion node can be as follows: Search the preset cache for a preprocessing result corresponding to the preprocessing cache key. If a corresponding preprocessing result is found, obtain the storage path of the preprocessing result. Read the data file set of the preprocessing result from the storage path. Calculate the actual digest value of the preprocessing result using the same digest algorithm as when it was first stored. Compare the actual digest value with the preset product digest value associated with the first storage of the preprocessing result. If the actual digest value matches the preset product digest value, the preprocessing result is confirmed to meet the consistency condition. The preset product digest value is the digest value obtained by hashing the data file of the preprocessing result when it is first generated and saved to the preset cache. After confirming that the consistency condition is met, configure the storage path of the preprocessing result as the input data source address of the branch format conversion node, and start the branch format conversion node to read the data file from the preprocessing result at that address for format conversion.

[0027] In one embodiment, the preprocessing result satisfies the consistency condition, including: the actual digest value of the preprocessing result is consistent with the preset product digest value associated with the preprocessing result, the actual digest value is obtained by hash calculation based on the data file content of the preprocessing result, and the preset product digest value is stored in association with the preprocessing cache key.

[0028] The actual digest value can be a hash value obtained by hashing the preprocessed result data file stored in the cache. This value is calculated in real time during verification and is used to compare with the expected value to verify the data integrity of the preprocessed result. The preset product digest value can be a digest value obtained by hashing the preprocessed result data file when the preprocessed result is first generated and saved to the preset cache. It is used to perform consistency verification on the actual digest value of the preprocessed result when the preprocessed cache key cache is hit, to verify whether the reused preprocessed result is complete and has not been tampered with. When the preset cache is hit, the actual digest value of the preprocessed result corresponding to the preprocessed cache key can be compared with the preset product digest value associated with the preprocessed result when it was first saved. If the actual digest value is consistent with the preset product digest value, the preprocessed result is confirmed to be complete and has not been tampered with, and the consistency verification is passed.

[0029] In one embodiment, ensuring the preprocessing result meets the consistency condition includes: locating the storage path of the preprocessing result corresponding to the preprocessing cache key in a preset cache; reading the data file of the preprocessing result according to the storage path; inputting all data content of the data file into a hash function for calculation to obtain the actual digest value of the preprocessing result; and obtaining the preset product digest value stored in the preset cache associated with the preprocessing cache key. This preset product digest value is the digest value obtained by hashing the data file of the preprocessing result when the preprocessing result corresponding to the preprocessing cache key is first saved to the preset cache. The calculated actual digest value is compared with the obtained preset product digest value. If the actual digest value is the same as the preset product digest value, it is determined that the preprocessing result meets the consistency condition.

[0030] Optionally, in the complete process of confirming that the preprocessing results meet the consistency conditions, before performing the digest value comparison, it is also necessary to confirm whether the product file corresponding to the preprocessing results exists. The specific method for confirming the existence of the product file can be: after obtaining the storage path of the preprocessing results from the cache system based on the preprocessing cache key, check whether a corresponding set of data files exists under that storage path. If no data files exist under that storage path, or the data file set is incomplete, such as lacking necessary index files, then it is directly determined that the preprocessing result does not meet the hit condition, and digest value comparison is unnecessary. Only when the existence of the product file and the completeness of the data file set are confirmed will the digest value comparison operation continue to verify the data integrity of the product file.

[0031] This scheme uses a preset product digest value stored in association with the preprocessing cache key as a benchmark reference to calculate the actual digest value of the preprocessing result to be reused in real time and perform a consistency comparison. This ensures the data integrity and tamper-proofness of the preprocessing result in the cache reuse process, avoids unreliable reuse due to data corruption, transmission errors or version inconsistencies, and improves the security and stability of reusing preprocessing results across training requests.

[0032] In one embodiment, the method further includes: if there is no preprocessing result corresponding to the preprocessing cache key in the preset cache or the consistency verification of the preprocessing result fails, preprocessing the genotype file in the breeding model training request based on the preset public preprocessing node to obtain the preprocessing result, wherein the preprocessing includes at least one of quality control filtering, genotype filling and index generation; and associating the preprocessing result with the preprocessing cache key and saving it to the preset cache.

[0033] The pre-processing cache can be a persistent data storage space that stores preprocessing results in a content-addressed manner, independent of the training process. This cache organizes and retrieves preprocessing results using the preprocessing cache key as an index, and preprocessing results with the same preprocessing cache key are uniquely stored in the cache. The pre-defined common preprocessing node can be a predefined computational node specifically designed to perform general preprocessing operations on genotype data. This node does not depend on any specific phenotype or algorithm, and its execution results can be shared by all downstream branch format conversion nodes and algorithm nodes. The genotype file can be a file recording the genotype data of an individual at multiple genetic loci. This file uses VCF format as the storage standard and contains genotype information for each sample at each locus, serving as the raw input data for all preprocessing operations. Preprocessing can be a series of data cleaning and transformation operations performed on the genotype file, including at least one of quality control filtering, genotype imputation, and index generation, which can process the raw genotype data into a standard dataset that can be used for subsequent format conversion and model training. Quality control filtering involves screening genetic loci in genotype files according to preset quality standards. This operation removes loci that do not meet quality requirements based on minimum allele frequency thresholds and deletion rate thresholds, retaining high-quality loci for subsequent analysis. Genotype imputation involves inferring and filling missing loci in the quality-controlled genotype data using known genotype information from the reference panel. This operation uses a hidden Markov model to probabilistically infer missing genotypes, producing complete and continuous genotype data after imputation. Index generation is an operation that builds auxiliary index files after preprocessing to facilitate quick reading and location of data by downstream tools. This operation generates corresponding index files for the imputed genotype data files to improve the efficiency of downstream format conversion and data reading.

[0034] In one embodiment, if the preprocessing result corresponding to the preprocessing cache key does not exist in the preset cache or the preprocessing result consistency check fails, the genotype file in the breeding model training request is preprocessed based on the preset common preprocessing node to obtain the preprocessing result. The specific method for saving the preprocessing result and the preprocessing cache key to the preset cache can be: when the preset cache is not found based on the preprocessing cache key, or when it is found but subsequent consistency checks fail, the preset common preprocessing node is marked as pending execution. The resource profile of the preset common preprocessing node includes the number of CPU cores, memory capacity, and estimated time required to execute PLINK quality control filtering and Beagle genotype filling. This resource profile is pre-configured in the attributes of the common preprocessing node and is used to determine whether the currently available resources of the system meet the startup conditions of the common preprocessing node before startup. The currently available resources of the system are obtained based on the resource profile of the preset common preprocessing node. If the resources are sufficient, the preset common preprocessing node is started. The preset common preprocessing node obtains the storage path of the genotype file from the breeding model training request and reads the genotype file according to the storage path. The PLINK tool is invoked through a preset common preprocessing node to perform quality control filtering on genotype files according to the MAF threshold and missing rate threshold carried in the breeding model training request. The Beagle tool is invoked through the preset common preprocessing node to infer and impute missing genotype sites in the quality-controlled genotype data using a specified reference panel. The preset common preprocessing node generates a corresponding index file for the imputed genotype data file. The imputed genotype data file and its index file are used together as the preprocessing result through the preset common preprocessing node. The preprocessing result is stored in a preset cache, and the preprocessing cache key is used as the index identifier of the preprocessing result to complete the associated saving.

[0035] Optionally, while saving the preprocessing result to a preset cache along with the preprocessing cache key, it is also necessary to mark the status of the preprocessing node. After the preset common preprocessing node completes execution and produces the preprocessing result, its execution status can be marked as successful. If subsequent training requests using the same preprocessing cache key hit the same preprocessing result, there is no need to re-execute the preset common preprocessing node; instead, the status of the preprocessing node is directly marked as a cache hit, which is equivalent to a successful status. Downstream branch format conversion nodes and algorithm nodes, when checking dependencies, consider preprocessing nodes with a cache hit status as successfully executed, thus triggering the execution of downstream nodes. In a typical training scenario involving four phenotypic traits and three algorithms, the initial preprocessing execution takes approximately 5 to 8 minutes. Subsequent training requests with the same preprocessing cache key can skip the preprocessing step after hitting the cache, shortening the overall training cycle by approximately 30% to 50%.

[0036] This solution, by triggering a preset common preprocessing node to perform preprocessing operations on the genotype file when there is no preprocessing result corresponding to the preprocessing cache key in the preset cache or when the consistency check of the preprocessing result fails, ensures the comprehensiveness of the preprocessing of the genotype file in the breeding model training request. Furthermore, it associates the output result with the preprocessing cache key and saves it to the preset cache, so that subsequent training requests with the same preprocessing cache key can directly hit and reuse it. After completing the necessary preprocessing calculations during the first execution, the results are retained, providing a data foundation for subsequent cross-request reuse, avoiding duplicate calculations caused by cache missing, and improving the overall execution efficiency in multi-training request scenarios.

[0037] S104, after the corresponding branch format conversion node completes the conversion of the preprocessing result, based on the dependency relationship, the preset resource profile of each algorithm node and the obtained available resource data, determine multiple concurrent nodes among multiple algorithm nodes, and execute multiple concurrent nodes.

[0038] The preset resource profile can be a pre-defined specification of the computing resources required for each algorithm to run. This specification includes at least the number of CPU cores, memory capacity, and whether GPU acceleration is required for the algorithm node to run. Different algorithms have different computing resource requirements. For example, the rrBLUP algorithm requires 2 CPU cores and 4GB of memory, the random forest algorithm requires 4 CPU cores and 8GB of memory, and deep learning algorithms require 8 CPU cores, 32GB of memory, and GPU acceleration. The preset resource profile is used to determine whether the currently available resources in the system meet the startup conditions of the algorithm node during scheduling decisions.

[0039] Optionally, in addition to including the number of CPU cores, memory capacity, and GPU requirements, the preset resource profile may also include the estimated time required for each algorithm node to execute the training task. The estimated time varies considerably between different algorithms; the rrBLUP algorithm takes approximately 1 to 3 minutes, the Random Forest algorithm takes approximately 5 to 15 minutes, and deep learning algorithms take approximately 20 to 60 minutes. This estimated time information is stored along with other fields from the resource profile in the algorithm configuration information.

[0040] In one embodiment, the estimated time consumption can also be included as an optional factor in the priority score calculation, in addition to the algorithm type, resource requirement, and DAG level position.

[0041] Available resource data can be real-time data on the system's remaining computing resources obtained when an algorithm node is executed. This data includes at least the number of currently unused CPU cores, the amount of currently unused memory, and the number of currently unused GPUs. Available resource data changes dynamically as algorithm nodes are started and released, serving as a crucial basis for resource access judgment and concurrency control. Concurrent nodes can be algorithm nodes that meet the startup conditions at the same time and can be executed simultaneously. For an algorithm node to meet the startup conditions, it must simultaneously satisfy the following: the predecessor node (i.e., the branch format conversion node) on which the algorithm node depends has completed execution, and the current available system resources are sufficient to meet all resource requirements defined in the algorithm node's preset resource profile.

[0042] In one embodiment, when the corresponding branch format conversion node completes the conversion of the preprocessing result, multiple concurrent nodes among multiple algorithm nodes are determined based on dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data. The specific method for executing these multiple concurrent nodes can be as follows: Monitor the execution status of the branch format conversion node. When the status of the branch format conversion node changes from "running" to "completed," traverse all algorithm nodes in the waiting state and check whether all dependencies of each algorithm node have been satisfied. For algorithm nodes whose dependencies have been satisfied, read the preset resource profile corresponding to that algorithm node to obtain the number of CPU cores, memory capacity, and GPU requirements required for the algorithm node to run. Simultaneously, obtain the number of CPU cores, memory capacity, and GPUs currently not occupied by the system as the current available resources. Compare the resource requirements of each algorithm node whose dependencies have been satisfied with the current available resources of the system. If the CPU, memory, and GPU requirements of a certain algorithm node do not exceed the corresponding current available resources of the system, then that algorithm node is determined as a concurrent node. Based on the preset node concurrency limit, select no more than the maximum number of nodes from all concurrent nodes, set these nodes to running status simultaneously, and start execution.

[0043] Optionally, before determining concurrent nodes, it is necessary to ensure that the number of currently running algorithm nodes has not reached the global node concurrency limit, and that there are available computing resources in the system to continue node scheduling. After the branch format conversion node completes the conversion of the preprocessing results, it can check whether the number of currently executing algorithm nodes has reached the preset global node concurrency limit. If the number of currently executing algorithm nodes has reached the preset global node concurrency limit, scheduling is paused, waiting for the executing nodes to release resources; if the number of currently executing algorithm nodes has not reached the preset global node concurrency limit, all algorithm nodes are traversed, and the dependencies and resource admission conditions of each algorithm node are checked one by one to determine the target nodes that can be executed concurrently.

[0044] In one embodiment, the specific method for executing multiple concurrent nodes can be as follows: The scheduler obtains the runtime environment information of the algorithm corresponding to each algorithm node, and determines the corresponding container image name based on this runtime environment information. The algorithm runtime environment includes an R language runtime environment and a Python language runtime environment, with the R language runtime environment corresponding to an R container image and the Python language runtime environment corresponding to a Python container image. The scheduler creates an independent container instance for each target algorithm node, configuring the execution entry script, input data source address, and runtime parameters of each algorithm node as the startup parameters of the corresponding container. The scheduler submits creation requests for each container to the container orchestration engine, enabling the container instances to start in parallel on the compute nodes. Each algorithm node executes its training task within its respective container. The containers of different algorithm nodes are isolated from each other and do not interfere with each other. The scheduler monitors the running status of each container in real time. When the training task in a container is completed, the scheduler reclaims the computing resources occupied by that container and records the execution result of that algorithm node. The scheduler can be the core control module in the breeding model training scheduling system responsible for managing and coordinating the execution order and resource allocation of each computing node. It is used to select algorithm nodes that meet the dependency conditions from the ready queue, check whether the system's currently available resources meet the startup requirements according to the preset resource profile of each algorithm node, allocate corresponding container images and computing resources to the algorithm nodes that meet the conditions, start the container to execute the training task, and monitor the execution status of each node in real time.

[0045] In one embodiment, determining multiple concurrent nodes among multiple algorithm nodes based on dependencies, preset resource profiles of each algorithm node, and acquired available resource data includes: determining multiple executable nodes among multiple algorithm nodes based on dependencies, and filtering multiple concurrent nodes among multiple executable nodes according to preset resource profiles of each executable node and acquired available resource data; correspondingly, executing multiple concurrent nodes includes: determining the execution priority corresponding to each executable node, and executing multiple concurrent nodes concurrently according to a preset global node concurrency limit and execution priority from high to low.

[0046] In this context, an executable node can be an algorithm node that has completed execution of all its predecessor nodes, satisfying all its dependencies and awaiting resource access before starting execution. A concurrent node can be an algorithm node that meets the startup conditions at the same time and can be executed simultaneously. For an algorithm node to meet the startup conditions, it must simultaneously satisfy: the predecessor nodes it depends on have completed execution; and the currently available system resources are sufficient to meet all resource requirements defined in the algorithm node's preset resource profile. All algorithm nodes that simultaneously meet both of these conditions can be marked as concurrent nodes. Execution priority can be assigned to each algorithm node and used to determine the order in which nodes are dequeued in the ready queue. Nodes with higher priority are placed at the front of the ready queue and are scheduled first during concurrent execution. Execution priority can be determined by a combination of one or more factors, including algorithm type, resource requirement size, or DAG (Directed Acyclic Graph) level position. The DAG in this scheme is, for example... Figure 4 As shown.

[0047] Figure 4 This is a multi-node dependent directed acyclic graph provided in the embodiments of this application. For example... Figure 4As shown in the diagram, there are multiple nodes: A, B1, B2, C11, C12, C13, C14, C21, and C22. A represents a common preprocessing node (upload→filter(PLINK)→impute(Beagle)), used to perform PLINK quality control filtering and Beagle genotype imputation on the input genotype VCF file, producing a unique "imputed VCF". This output is reused by all subsequent nodes. B1 and B2 represent two branch format conversion nodes. B1 is an R branch format conversion node (i.e., R branch format conversion VCF→PLINK raw), used to convert the imputed VCF produced by node A into PLINK raw format; B2 represents a GS branch format conversion node (i.e., GS branch format conversion VCF→PED→matrix CSV), used to convert the imputed VCF produced by A into matrix CSV format. Different algorithms have different requirements for input data format; B1 and B2 provide different data input formats for R language algorithms (rrBLUP, RF) and Python deep learning algorithms (GS), respectively. In this framework, RF (Random Forest) is used. C11-C22 represent algorithm nodes used to perform model training tasks. Specifically, C11 represents plant height_rrBLUP, C12 represents plant height_RF, C13 represents yield_rrBLUP, C14 represents yield_RF, C21 represents plant height_GS, and C22 represents yield_GS. Each C node corresponds to an independent "phenotype × algorithm" combined training task. For example, C11 represents training a breeding model using the rrBLUP algorithm for the "plant height" phenotype, and C21 represents training the "plant height" model using the GS deep learning algorithm. All six C nodes share a single preprocessing output from B1. Specifically, C11-C14 share the raw format conversion results from B1; and C21-C22 share the matrix CSV format conversion results from B2. B1 and B2 both depend on A completing first; C11-C14 depend on B1 completing the raw format conversion first; C21-C22 depend on B2 completing the matrix CSV format conversion first. The node pointed to by the arrow can only start execution after the node from which the arrow originates has completed. The four algorithm nodes (rrBLUP, RF) in the R branch (C11-C14) share one raw conversion; the two algorithm nodes (GS) in the GS branch (C21-C22) share one matrix conversion. Compared to independent preprocessing for each task, the number of preprocessing executions is reduced from 6 to 1.

[0048] The preset global node concurrency limit can be the maximum number of algorithm nodes allowed to execute simultaneously. This limit is determined by the smaller of the user-configured maximum concurrency and the system's preset maximum number of containers. It is used to control the system's concurrent load and avoid system resource overload caused by too many algorithm nodes executing simultaneously. For example, if the user-configured maximum concurrency is 2 and the system's preset maximum number of containers is 3, then the smaller value of 2 is taken as the preset global node concurrency limit.

[0049] In one embodiment, the specific method for determining multiple executable nodes among multiple algorithm nodes based on dependencies can be as follows: traverse all algorithm nodes and check the predecessor node (i.e., the branch format conversion node) of each algorithm node to see if it has been completed. For algorithm nodes whose predecessor nodes have been completed, mark them as executable nodes and add them to the candidate set; for algorithm nodes whose predecessor nodes have not been completed, keep them in a waiting state. The specific method for filtering multiple concurrent nodes among multiple executable nodes based on the preset resource profiles of each executable node and the obtained available resource data can be as follows: obtain the preset resource profiles of each executable node in the candidate set and obtain the system's currently available resource data from the resource management module. Compare the resource requirements of each executable node with the system's currently available resources one by one. If the CPU, memory, and GPU requirements of an executable node do not exceed the system's currently available resources, then the executable node is marked as a concurrent node. If any resource requirement of an executable node exceeds the system's currently available resources, then the node does not meet the concurrent execution conditions and waits for system resources to be released before re-entering the filtering process. The specific method for determining the execution priority corresponding to each executable node and executing multiple concurrent nodes concurrently according to the preset global node concurrency limit and the execution priority from high to low can be as follows: Obtain the execution priority of each executable node, read the user-configured maximum concurrency from the configuration module, read the system-preset maximum number of containers from the system module, and determine the smaller of the two values ​​as the preset global node concurrency limit. At the beginning of the scheduling cycle, obtain the number of currently executing algorithm nodes, determine the number of currently idle concurrent slots, sort all algorithm nodes marked as concurrent nodes according to their execution priority from high to low, select nodes from the sorted concurrent node queue whose number does not exceed the number of currently idle concurrent slots, set these nodes to the running state simultaneously, and start container execution. The execution priority can be determined as follows: Assign weight coefficients (e.g., 0.4, 0.3, 0.3) to the algorithm type, resource requirement, and DAG level position. When only some of these three factors are selected, redistribute the weight coefficients of each selected factor according to their original proportions, ensuring the sum of the weight coefficients of all selected factors is 1. Quantize each factor into a score from 0 to 1, then sum them weighted to obtain the priority score for each algorithm node; the higher the score, the higher the priority. Specifically, the algorithm type is mapped to a score according to the rule that classic algorithms such as rrBLUP / RF have higher priority than deep learning algorithms; the resource requirement is mapped to a score according to the rule that smaller requirements have higher priority; and the DAG level position is mapped to a score according to the rule that higher levels have higher priority. The algorithm type is quantized according to a preset mapping relationship.For example: classic statistical and machine learning algorithms such as rrBLUP and RF are assigned a score of 1, while deep learning algorithms are assigned a score of 0; resource requirements are normalized by the number of CPU cores and memory capacity respectively, and the average value is taken. Then, 1 is subtracted from the average value to obtain the score. For algorithm nodes that require GPUs, the score is reduced by 0.1. All algorithm nodes within the same scheduling cycle use the same resource measurement method; the DAG level position is normalized by the level number, with higher levels receiving higher scores. If all executable nodes within the same scheduling cycle have the same value for a certain factor, then the score for that factor is uniformly set to 1; if two algorithm nodes have the same priority score, they are sorted according to the order of their task identifiers.

[0050] Optionally, the preset global node concurrency limit is determined by the user-configured maximum concurrency and the system-preset maximum number of containers. The user-defined maximum concurrency is read from the user configuration, and the system-preset maximum number of containers is read from the system configuration. This maximum number of containers represents the absolute upper limit of algorithm nodes allowed to run concurrently at the system level. The user-configured maximum concurrency and the system-preset maximum number of containers are compared, and the smaller value is taken as the preset global node concurrency limit. At the beginning of each scheduling cycle, the number of algorithm nodes currently executing is obtained, the number of remaining available concurrent slots is determined, and the top N nodes (N not exceeding the number of remaining concurrent slots) in the queue of concurrent nodes, sorted by execution priority, are selected as the target nodes for this scheduling. If the number of concurrent nodes is greater than the number of remaining concurrent slots, nodes with higher execution priority are prioritized for scheduling, and the remaining nodes wait for the next scheduling cycle to participate in the selection process again.

[0051] This solution selects all algorithm nodes whose dependencies are satisfied as executable nodes based on dependency relationships. Then, based on the preset resource profile of each executable node and the system's currently available resource data, it selects concurrent nodes that meet resource requirements from the executable nodes. This solution can determine concurrent nodes at both the dependency and resource selection levels, avoiding startup failures due to insufficient resources or execution anomalies due to unmet dependencies. Furthermore, by determining the execution priority corresponding to each executable node and executing multiple concurrent nodes concurrently according to the preset global node concurrency limit and execution priority from high to low, it ensures that multiple algorithm nodes can be automatically and accurately executed concurrently without manual intervention. This improves the automation level of node scheduling and the rationality of concurrent execution in multi-algorithm scenarios.

[0052] In one embodiment, the number of concurrent nodes is less than the total number of algorithm nodes. During the execution of multiple concurrent nodes, the method further includes: obtaining the execution status of each concurrent node; if there are algorithm nodes with a failed execution status, filtering out the failed algorithm nodes to obtain multiple remaining nodes; obtaining the current remaining resources, determining the executable nodes among the multiple remaining nodes based on dependencies, the preset resource profiles of each remaining node, and the current remaining resources, and executing the executable nodes.

[0053] The execution status can be a task lifecycle stage identifier recorded by the scheduler during the execution of algorithm nodes. Execution status includes running, successful, and failed states. The scheduler monitors the execution status of each algorithm node to determine whether a task has completed normally or terminated abnormally, and triggers subsequent scheduling decisions based on the status. For example, successful execution releases resources and marks the node as complete; failed execution triggers a failure isolation process. Remaining nodes can be all other algorithm nodes that have not been marked as failed after filtering out those with failed execution status. Remaining nodes include other currently running nodes, nodes that have completed execution but have not triggered any exceptions, and waiting nodes that have not yet started. Remaining nodes continue to participate in subsequent scheduling after failing nodes are filtered out and are not terminated or skipped due to the failure of a single node.

[0054] In one embodiment, the specific method for obtaining the execution status of each concurrent node during the execution of multiple concurrent nodes can be as follows: when the number of concurrently started algorithm nodes does not reach the total number of algorithm nodes, the process exit code and runtime log of each started algorithm node are continuously monitored through the container runtime interface to obtain the execution status of each algorithm node. In the case of algorithm nodes with a failed execution status, the specific method for filtering out failed algorithm nodes to obtain multiple remaining nodes can be as follows: when a non-zero process exit code of an algorithm node is detected or an exception is recorded in the runtime log, the execution status of that algorithm node is marked as failed and the reason for failure is recorded. The failed algorithm node is removed from the global algorithm node list to obtain multiple remaining nodes. The specific method for obtaining the current remaining resources, determining the executable nodes among the multiple remaining nodes based on dependencies, the preset resource profiles of each remaining node, and executing the executable nodes can be as follows: releasing the CPU, memory, and GPU resources occupied by the failed nodes, thereby increasing the amount of currently available resources in the system, and obtaining the released current remaining resources. Traverse all remaining nodes that have not been marked as failed and have not yet been executed, check whether the dependencies of each remaining node have been satisfied. For remaining nodes whose dependencies have been satisfied, obtain the preset resource profile of the remaining node, compare the resource profile with the current remaining resources, and if the CPU requirement, memory requirement and GPU requirement of a certain remaining node do not exceed the current remaining resources, then determine the remaining node as a new executable node and start execution immediately through the scheduler.

[0055] Optionally, if a branch format conversion node fails to execute, i.e., when the process exit code of a branch format conversion node is detected to be non-zero or an exception is recorded in the running log, the branch format conversion node is marked as failed. All algorithm nodes are traversed to find the algorithm nodes that depend on the branch format conversion node. The status of these algorithm nodes is marked as skipped, and the reason for skipping is recorded as the failure of the branch format conversion node they depend on. Algorithm nodes of other branches that do not depend on the branch format conversion node are unaffected and continue to execute.

[0056] This solution obtains the execution status of each concurrent node in real time. When there is an algorithm node in a failed execution state, it filters out the failed node and releases the resources it occupies. This ensures that the failure of a single node only affects the node itself and does not affect the normal operation of other nodes that are executing or waiting to be executed. It avoids global training interruption or long-term resource occupation caused by single node failure, improves the fault tolerance of concurrent execution of multiple algorithms in batch training scenarios, and can automatically fill in the gap and continue the scheduling of the remaining nodes without manual intervention after a failure occurs. It avoids the impact of single node failure on the overall training efficiency and improves the execution efficiency and resource utilization of multiple algorithm nodes.

[0057] Optionally, after each algorithm node has completed concurrent execution, it is also necessary to record complete product lineage information for each training task to ensure the traceability of training results. The specific method for recording product lineage information can be as follows: After multiple concurrent nodes have completed execution, obtain the execution results of each algorithm node. The execution results include the trained model file, model performance index file, and training log file. Record the input data source information for each algorithm node, including a summary of the genotype file's content and the file identifier and phenotypic column number of the phenotypic file. Record the version information used during the execution of each algorithm node, including the preprocessing cache key, format conversion script version, and algorithm training script version. Record the runtime configuration information during the execution of each algorithm node, including the container image name, runtime parameter snapshot, and training completion time. Summarize the above information into a product lineage record and store it in association with the execution results of each algorithm node.

[0058] Optionally, after recording the product lineage information of each algorithm node, it is also necessary to summarize the execution results of each algorithm node so that users can compare the prediction performance of different models on the same or different phenotypes. The specific method for summarizing the execution results of each algorithm node can be: summarizing the accuracy data, failure reasons, and training time of each algorithm node according to both phenotype and algorithm dimensions, generating a performance comparison table for multiple algorithms and multiple phenotypes, and outputting it to the user interface.

[0059] The technical solution provided in this application, in response to a breeding model training request, generates a training task matrix and a preprocessing cache key corresponding to the breeding model training request; determines multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependencies between the multiple branch format conversion nodes and the multiple algorithm nodes; obtains preprocessing results that meet the consistency conditions from a preset cache based on the preprocessing cache key, and inputs the preprocessing results to the corresponding branch format conversion node; when the corresponding branch format conversion node completes the conversion of the preprocessing results, determines multiple concurrent nodes among the multiple algorithm nodes based on the dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, and executes the multiple concurrent nodes. The multi-algorithm node concurrent execution method described above solves the problems of serious waste of redundant computing power and unreasonable resource scheduling of multi-algorithm node execution in the existing technology. By generating a training task matrix and a preprocessing cache key corresponding to the breeding model training request, and obtaining preprocessing results that meet the consistency conditions from the preset cache based on the preprocessing cache key, and inputting the preprocessing results to the corresponding branch format conversion node, the purpose of reusing preprocessing results can be achieved, avoiding the waste of computing power caused by repeated preprocessing. Furthermore, by executing multiple algorithm nodes concurrently based on the inter-node dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, the rationality of resource scheduling for multi-algorithm node execution is improved.

[0060] Figure 2 This is a flowchart illustrating a method for generating preprocessed cache keys provided in an embodiment of this application. For example... Figure 2 As shown, the specific steps include the following: S201, parse the breeding model training request to obtain the phenotypic set, algorithm set and genotype file.

[0061] The phenotypic column set can be the collection of all phenotypic trait columns in the phenotypic data file carried in the breeding model training request. Phenotypic traits are target traits that need to be predicted or evaluated in breeding research, such as plant height, yield, and disease resistance. Phenotypic data files are usually stored in tabular form, with each column representing a phenotypic trait and each row representing a sample individual. Each phenotypic column in the phenotypic column set will be combined with each algorithm in the algorithm set to form an independent training task. The algorithm set can be the collection of algorithms to be executed carried in the breeding model training request. This set contains at least one algorithm, and when it contains multiple algorithms, each algorithm will be combined with each phenotypic trait in the phenotypic column set to form multiple training tasks. The algorithms in the algorithm set include statistical modeling algorithms based on R language and deep learning algorithms based on Python, such as rrBLUP, random forest, GBLUP, support vector machines, and deep learning models.

[0062] In one embodiment, the specific method for parsing the breeding model training request to obtain the phenotypic column set, algorithm set, and genotype file can be as follows: Upon receiving the breeding model training request, the storage path of the phenotypic data file, the list of algorithm identifiers, and the storage path of the genotype file are read from the request body. The phenotypic data file is read according to its storage path, and the header information is parsed to identify all column names in the file. Target columns representing phenotypic traits are selected from the column names, and their column names and column numbers are read. All selected phenotypic trait columns are combined into a phenotypic column set. Based on each algorithm identifier in the algorithm identifier list, preset algorithm configuration information is queried, and the algorithm names and algorithm type information corresponding to all algorithm identifiers in the algorithm identifier list are summarized into an algorithm set. The location information of the genotype file is recorded according to its storage path as the data source for subsequent preprocessing operations.

[0063] S202, the phenotypic column set and the algorithm set are combined in a Cartesian fashion to generate a training task matrix corresponding to the breeding model training request.

[0064] Cartesian combination involves pairing elements from two sets so that every element in the first set is paired with every element in the second set. In this scheme, Cartesian combination pairs each phenotypic trait in the phenotypic column set with each algorithm in the algorithm set, generating all possible phenotypic-algorithm combinations. If the phenotypic column set contains M phenotypic traits and the algorithm set contains N algorithms, then Cartesian combination generates M×N combination pairs, each corresponding to an independent training task.

[0065] In one embodiment, the specific method for generating the training task matrix corresponding to the breeding model training request by performing a Cartesian combination of the phenotypic column set and the algorithm set can be as follows: Read the first phenotypic trait in the parsed phenotypic column set, pair this phenotypic trait with each algorithm in the algorithm set, generating N phenotypic-algorithm combinations corresponding to this phenotypic trait. Continue reading the next phenotypic trait in the phenotypic column set, similarly pairing it with each algorithm in the algorithm set, generating N phenotypic-algorithm combinations corresponding to this phenotypic trait. Repeat the above operation until all M phenotypic traits in the phenotypic column set have been traversed, generating a total of M×N phenotypic-algorithm combinations. Organize the generated M×N phenotypic-algorithm combinations in tabular form, with phenotypic traits as rows and algorithms as columns, constructing an M-row N-column two-dimensional table. Output this two-dimensional table as the training task matrix. Each cell in the matrix records a phenotypic-algorithm combination and its corresponding task identifier.

[0066] S203 generates a preprocessing cache key corresponding to the breeding model training request based on the file content summary information, quality control parameters, and preprocessing software version in the genotype file.

[0067] The file content summary information can be a fixed-length string obtained by hashing all the data content of the genotype file. This summary information uniquely identifies the data content of the genotype file. Any change in the file content, such as modification, site updates, or sample additions or removals, will result in different summary information. The file content summary information is used to ensure that the preprocessing cache key is strictly bound to the data content of the genotype file, preventing different genotype files from generating the same preprocessing cache key. Quality control parameters can be numerical or enumerated parameters carried in the breeding model training request to control the quality control filtering process of genotype data. Quality control parameters include at least a minimum allele frequency threshold and a missing rate threshold. The minimum allele frequency threshold is used to filter rare variant sites, and the missing rate threshold is used to filter sites with excessively high missing rates. The specific values ​​of the quality control parameters directly affect the data content of the preprocessed output. The preprocessing software version can be the external tools and their version identifiers used to perform the preprocessing operations. The preprocessing software version includes at least the version number of the PLINK tool, the version number of the Beagle tool, and the reference panel version. Different versions of PLINK or Beagle tools may differ in their algorithm implementation, leading to variations in the preprocessed results. The reference panel version is the version identifier of the reference panel used when performing Beagle genotype imputation. A reference panel is a known genotype reference dataset upon which Beagle genotype imputation relies. Differences in sample composition, site coverage, and haplotype structure between different versions of reference panels can result in different imputation results for the same genotype data.

[0068] In one embodiment, the specific method for generating a preprocessing cache key corresponding to the breeding model training request based on the file content summary information, quality control parameters, and preprocessing software version in the genotype file can be as follows: The genotype file is read according to its storage path; all data content of the genotype file is input into a SHA256 hash function for calculation to obtain the file content summary information of the genotype file. The quality control parameters carried in the breeding model training request are read to obtain the specific values ​​of the minimum allele frequency threshold and the missing rate threshold. The PLINK version number and Beagle version number used to perform the preprocessing operation are read from the configuration information, along with the reference panel version identifier used for Beagle genotype imputation. Following a preset concatenation order, the file content summary information, minimum allele frequency threshold, missing rate threshold, PLINK version number, Beagle version number, and reference panel version are sequentially concatenated into a string, with separators inserted between adjacent fields. The concatenated string is input into a SHA256 hash function for calculation, and the calculated hash value is used as the preprocessing cache key corresponding to the breeding model training request.

[0069] The technical solution provided in this application, by parsing breeding model training requests to obtain phenotypic column sets, algorithm sets, and genotype files, can automatically transform unstructured training requests submitted by users into structured data objects. This provides a clear data foundation for subsequent task matrix generation and preprocessing cache key construction, avoiding omissions or errors that are prone to occur when manually configuring multiple training tasks. By generating a training task matrix through a Cartesian combination of the phenotypic column set and the algorithm set, a complete task list corresponding to all phenotypic and algorithm combinations can be generated at once, eliminating the need for users to create them one by one, thus improving the completeness and efficiency of task configuration. By generating preprocessing cache keys based on the file content summary information, quality control parameters, and preprocessing software version in the genotype file, misuse of cached results due to files with the same name but different content or parameter adjustments is avoided, ensuring the accuracy and reliability of the cache reuse mechanism across different requests.

[0070] Figure 3 This is a flowchart of a node dependency determination method provided in an embodiment of this application. Figure 3 As shown, the specific steps include the following: S301, determine multiple algorithm nodes corresponding to each training task based on the target algorithm corresponding to each training task in the training task matrix.

[0071] The target algorithm can be a specific algorithm used to model the phenotypic trait corresponding to a training task. Each training task in the training task matrix consists of a phenotypic trait and an algorithm, where the algorithm is the target algorithm for that training task. The target algorithm determines the container image type, resource profile, and input data format requirements used during the execution of the training task. Different training tasks can use the same target algorithm, such as two different phenotypic traits both using the rrBLUP algorithm; or they can use different target algorithms, such as one using rrBLUP and the other using deep learning.

[0072] In one embodiment, the specific method for determining multiple algorithm nodes corresponding to each training task based on the target algorithm corresponding to each training task in the training task matrix can be as follows: First, read the first training task from the training task matrix, obtain the target algorithm identifier recorded in that training task, and query the preset algorithm configuration information based on the target algorithm identifier. Obtain the execution entry script path and running parameter template for that algorithm, create an algorithm node object for that training task, set the node type of the algorithm node object to the node type corresponding to the target algorithm identifier, and record the phenotypic name, algorithm name, and task identifier of the training task in the attributes of the algorithm node object. Continue reading the next training task from the training task matrix, repeating the above operations until all training tasks in the training task matrix have been traversed, generating an independent algorithm node for each training task. All algorithm nodes together constitute the algorithm node set corresponding to the training task matrix.

[0073] S302, determine the branch format conversion node corresponding to each algorithm node based on the target input format of each algorithm node, and determine the dependency relationship between multiple branch format conversion nodes and multiple algorithm nodes according to the correspondence between each algorithm node and each branch format conversion node.

[0074] The target input format can be the specific file format of the genotype data required by an algorithm node when performing a training task. Different algorithms have different requirements for input data formats. R language algorithms, such as rrBLUP and Random Forest, require PLINK raw format as input, while Python deep learning algorithms require matrix CSV format as input. The target input format determines which branch format conversion node the algorithm node should rely on to obtain input data that meets its requirements.

[0075] In one embodiment, the specific method for determining the branch format conversion node corresponding to each algorithm node based on the target input format of each algorithm node can be as follows: traverse all algorithm nodes, obtain the target algorithm identifier of the current algorithm node, query a preset algorithm configuration mapping table according to the target algorithm identifier, read the input format type corresponding to the target algorithm from the mapping table, use the read input format type as the target input format of the algorithm node, query the preset branch format conversion mapping table according to the target input format, and determine the branch type to which the target input format belongs. The specific method for determining the dependency relationship between multiple branch format conversion nodes and multiple algorithm nodes based on the correspondence between each algorithm node and each branch format conversion node can be as follows: according to the determined branch type, assign the algorithm node to the corresponding branch format conversion node, associate all algorithm nodes belonging to the same branch type with the same branch format conversion node, establish a dependency edge for the algorithm node pointing to the branch format conversion node, indicating that the algorithm node can only start after the branch format conversion node has completed execution, and summarize the dependency edges of all algorithm nodes to obtain the complete dependency relationship between multiple branch format conversion nodes and multiple algorithm nodes.

[0076] Optionally, format conversion nodes in different branches are independent of each other. Failure of a format conversion node in one branch does not affect the format conversion nodes in other branches or the algorithm nodes under that branch. Independent branch format conversion nodes can be created for the R branch and the GS branch respectively. There is no dependency between the two branch format conversion nodes; they can be executed independently after their respective predecessor nodes (i.e., common preprocessing nodes) are completed. When a branch format conversion node fails, only the algorithm nodes under that branch are marked as skipped; the format conversion nodes and algorithm nodes in the other branch continue to execute unaffected.

[0077] The technical solution provided in this application determines multiple algorithm nodes corresponding to each training task based on the target algorithm of each training task in the training task matrix, and determines branch format conversion nodes corresponding to each algorithm node based on the target input format of each algorithm node. This can merge algorithm nodes with the same target input format under the same branch format conversion node, improving the accuracy of determining task dependencies in multi-algorithm scenarios. Furthermore, by determining the dependency relationship between each algorithm node and each branch format conversion node based on their correspondence, it can ensure that the branch format conversion node, as a predecessor node of the algorithm node, is only started after the data required by the algorithm node has been converted according to the target format. This avoids execution anomalies caused by input data format mismatch and ensures the success rate of subsequent task processing.

[0078] Figure 5 This is a flowchart of a multi-node-based task processing method provided in an embodiment of this application. Figure 5 As shown, the specific steps include the following: S501, the task matrix has been created, awaiting the fulfillment of dependencies.

[0079] In one embodiment, in response to a breeding model training request, after generating a training task matrix and preprocessing cache key corresponding to the breeding model training request, the scheduler creates an algorithm node for each phenotype and algorithm combination in the training task matrix and sets the initial state of the algorithm node to Pending. In the Pending state, the scheduler continuously monitors the execution status of the predecessor nodes (i.e., common preprocessing nodes and corresponding branch format conversion nodes) that the algorithm node depends on, until the execution status of all predecessor nodes is either Succeeded or Cached, at which point the dependency condition of the algorithm node is considered satisfied.

[0080] S5021, preprocessing or format conversion has been successfully completed, node dependencies are ready, and the system is waiting to allocate computing resources.

[0081] In one embodiment, when the scheduler detects that all predecessor nodes (i.e., common preprocessing nodes and corresponding branch format conversion nodes) of an algorithm node have completed execution and are in the Succeeded or Cached state, the scheduler transitions the algorithm node's state from Pending to Ready. This indicates that all the node's dependencies have been met, it can be scheduled for execution, and is waiting for the system to allocate computing resources. In the Ready state, the scheduler adds the algorithm node to the ready queue, sorts it according to the node's execution priority, and waits for the scheduling cycle to arrive to perform resource admission checks.

[0082] S5022, preprocessing cache hit, product reuse successful, waiting for system to allocate computing resources.

[0083] In one embodiment, when an algorithm node is in the Pending state, the scheduler queries the preset cache to see if there is a preprocessing result corresponding to the preprocessing key. If there is, and the preprocessing result meets the consistency condition, the state of the common preprocessing node is marked as Cached (cache hit), indicating that the content addressing cache has been hit and the existing preprocessing product can be directly reused without re-executing the preprocessing operation. The Cached state is equivalent to the Succeeded state. When checking the dependency conditions, the algorithm node regards the common preprocessing node in the Cached state as having been successfully executed, thereby transitioning the state of the algorithm node from Pending to Ready.

[0084] S5023, Preprocessing or format conversion failed.

[0085] In one embodiment, when the scheduler detects that a predecessor node (i.e., a common preprocessing node or a corresponding branch format conversion node) on which an algorithm node depends has failed, the scheduler transitions the algorithm node's state from Pending to Skipped, indicating that the node is skipped directly because its dependency cannot be satisfied and will no longer participate in subsequent scheduling. If the failed predecessor node is a branch format conversion node, all algorithm nodes that depend on that branch format conversion node are marked as Skipped, while algorithm nodes on the other branch are unaffected and continue execution.

[0086] S5031 performs training tasks within a container.

[0087] In one embodiment, after the scheduler selects an algorithm node as the target node from the ready queue, it checks whether the system's currently available resources meet the startup requirements based on the preset resource profile of the algorithm corresponding to that algorithm node. If the resources meet the requirements, the scheduler determines the corresponding container image name (R container image for R language runtime environment, Python container image for Python language runtime environment) based on the runtime environment information of the algorithm node, creates an independent container instance for the algorithm node, configures the execution entry script, input data source address, and running parameters of the algorithm node as the startup parameters of the container, submits a container creation request to the container orchestration engine, and transitions the state of the algorithm node from Ready to Running, so that the algorithm node can execute training tasks in the container.

[0088] S5032, in the event that the branch format conversion node fails to process, triggers the hierarchical isolation of the branch format conversion node.

[0089] In one embodiment, when the scheduler detects that the process exit code of a branch format conversion node is non-zero or that an exception is recorded in the execution log, it marks the execution status of that branch format conversion node as Failed and triggers hierarchical isolation of the branch format conversion node. The scheduler traverses all algorithm nodes, finds algorithm nodes that depend on this branch format conversion node, marks the status of these algorithm nodes as Skipped, and records the reason for skipping them as the failure of the branch format conversion node they depend on; algorithm nodes of other branches that do not depend on this branch format conversion node are unaffected and continue to execute.

[0090] S5041, if the preset algorithm node successfully executes the training task in the container, outputs the model product.

[0091] In one embodiment, after the algorithm node completes the training task in the container, the scheduler obtains the process exit code and running log of the container. If the process exit code is 0 and the product verification passes (i.e. the model product file output by the algorithm node is complete and in the correct format), the execution status of the algorithm node is transitioned from Running to Succeeded, indicating that the algorithm node has successfully executed and produced model products. This state is the final state.

[0092] S5042, if the preset algorithm node fails to execute the training task in the container, trigger the hierarchical isolation of the algorithm node.

[0093] In one embodiment, when the scheduler detects that the process exit code of an algorithm node is non-zero or that abnormal information (such as execution timeout or missing artifacts) is recorded in the execution log, the execution status of the algorithm node is transitioned from Running to Failed, triggering hierarchical isolation of the algorithm node. The scheduler removes the failed node from the global algorithm node list, does not retry it, and does not terminate other algorithm nodes that are executing or waiting to execute; at the same time, the failed node releases the CPU, memory, and GPU resources it occupied, thereby increasing the amount of available resources in the system for use by other algorithm nodes.

[0094] The hierarchical failure isolation mechanism in this scheme includes two levels: hierarchical isolation of the branch format conversion node corresponding to S5032. When the branch format conversion node fails, all algorithm nodes under that branch are marked as Skipped, while the algorithm nodes of the other branch are unaffected. Hierarchical isolation of the algorithm nodes corresponding to S5042. When a single algorithm node fails, only that node itself is marked as Failed, while other algorithm nodes continue to execute unaffected. The above state machine definition and hierarchical failure isolation mechanism describe the complete lifecycle of a training node from creation to execution completion or failure, providing state-level support for failure isolation.

[0095] Figure 6 This is a structural block diagram of a multi-algorithm node concurrent execution device for a training task provided in an embodiment of this application. Figure 6 As shown, it specifically includes: The training task generation module 601 is used to generate a training task matrix and a preprocessing cache key corresponding to the breeding model training request in response to the breeding model training request. The dependency determination module 602 is used to determine multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependency relationships between the multiple branch format conversion nodes and the multiple algorithm nodes. The preprocessing module 603 is used to obtain the preprocessing result that meets the consistency condition from the preset cache based on the preprocessing cache key, and input the preprocessing result into the corresponding branch format conversion node; The concurrent execution module 604 is used to determine multiple concurrent nodes among multiple algorithm nodes based on dependencies, the preset resource profiles of each algorithm node and the obtained available resource data, and execute multiple concurrent nodes after the corresponding branch format conversion node has completed the conversion of the preprocessing results.

[0096] The technical solution provided in this application includes a training task generation module, used to generate a training task matrix and a preprocessing cache key corresponding to the breeding model training request in response to the breeding model training request; a dependency determination module, used to determine multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependency relationships between the multiple branch format conversion nodes and the multiple algorithm nodes; a preprocessing module, used to obtain preprocessing results that meet the consistency conditions from a preset cache based on the preprocessing cache key, and input the preprocessing results to the corresponding branch format conversion node; and a concurrent execution module, used to determine multiple concurrent nodes among the multiple algorithm nodes based on the dependency relationships, the preset resource profiles of each algorithm node, and the obtained available resource data, and execute the multiple concurrent nodes after the corresponding branch format conversion node has completed the conversion of the preprocessing results. The multi-algorithm node concurrent execution device for the aforementioned training tasks solves the problems of serious waste of repetitive computing power and unreasonable resource scheduling for multi-algorithm node execution in existing technologies. By generating a training task matrix and a preprocessing cache key corresponding to the breeding model training request, and obtaining preprocessing results that meet the consistency conditions from the preset cache based on the preprocessing cache key, and inputting the preprocessing results to the corresponding branch format conversion node, the purpose of reusing preprocessing results can be achieved, avoiding the waste of computing power caused by repeated preprocessing. Furthermore, by executing multiple algorithm nodes concurrently based on the inter-node dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, the rationality of resource scheduling for multi-algorithm node execution is improved.

[0097] Furthermore, the preprocessing results meet the consistency conditions, including: The actual summary value of the preprocessing result is consistent with the preset product summary value associated with the preprocessing result. The actual summary value is obtained by hashing the data file content of the preprocessing result, and the preset product summary value is stored in association with the preprocessing cache key.

[0098] Furthermore, the preprocessing module 603 is also used for: If the preprocessing result corresponding to the preprocessing cache key does not exist in the preset cache or the consistency check of the preprocessing result fails, the genotype file in the breeding model training request is preprocessed based on the preset common preprocessing node to obtain the preprocessing result. The preprocessing includes at least one of quality control filtering, genotype filling and index generation. The preprocessing results are associated with the preprocessing cache key and saved to the preset cache.

[0099] Furthermore, the concurrent execution module 604 is specifically used for: Based on the dependency relationship, multiple executable nodes are determined among multiple algorithm nodes, and multiple concurrent nodes among multiple executable nodes are selected according to the preset resource profile of each executable node and the obtained available resource data. Accordingly, multiple concurrent nodes are executed, including: Determine the execution priority corresponding to each executable node, and execute multiple concurrent nodes concurrently in descending order of preset global node concurrency limit and execution priority.

[0100] Furthermore, the training task generation module 601 is specifically used for: Parse the breeding model training request to obtain the phenotypic column set, algorithm set, and genotype file; The phenotypic set and the algorithm set are combined in a Cartesian fashion to generate a training task matrix corresponding to the breeding model training request. Based on the file content summary information, quality control parameters, and preprocessing software version in the genotype file, a preprocessing cache key corresponding to the breeding model training request is generated.

[0101] Furthermore, the dependency determination module 602 is specifically used for: Based on the target algorithm corresponding to each training task in the training task matrix, determine multiple algorithm nodes corresponding to each training task; Based on the target input format of each algorithm node, the branch format conversion node corresponding to each algorithm node is determined, and the dependency relationship between multiple branch format conversion nodes and multiple algorithm nodes is determined according to the correspondence between each algorithm node and each branch format conversion node.

[0102] Furthermore, the concurrent execution module 604 is also used for: Obtain the execution status of each concurrent node; If there are algorithm nodes in the execution state of failure, filter out the algorithm nodes in the failure state to obtain multiple remaining nodes; Obtain the current remaining resources, determine the executable node among multiple remaining nodes based on the dependency relationship, the preset resource profile of each remaining node and the current remaining resources, and execute the executable node.

[0103] This application also provides an electronic device, which can integrate a multi-algorithm node concurrent execution device for a training task provided in this application. Figure 7 This is a schematic diagram of the structure of a multi-algorithm node concurrent execution device for a training task provided in an embodiment of this application. (Refer to...) Figure 7 The multi-algorithm node concurrent execution device for this training task includes: an input device 53, an output device 54, a memory 52, and one or more processors 51; the memory 52 is used to store one or more programs; when one or more programs are executed by one or more processors 51, the one or more processors 51 implement the multi-algorithm node concurrent execution method for the training task as provided in the above embodiments. The input device 53, output device 54, memory 52, and processors 51 can be connected via a bus or other means. Figure 7 Taking the example of a connection between China and Israel via a bus.

[0104] The memory 52, as a computing device readable storage medium, can be used to store software programs, computer-executable programs, and modules, such as the program instructions / modules corresponding to the multi-algorithm node concurrent execution method for training tasks provided in any embodiment of this application. The memory 52 may primarily include a program storage area and a data storage area. The program storage area may store the operating system and at least one application program required for a function; the data storage area may store data created based on the use of the device, etc. Furthermore, the memory 52 may include high-speed random access memory and may also include non-volatile memory, such as at least one disk storage device, flash memory device, or other non-volatile solid-state storage device. In some instances, the memory 52 may further include memory remotely located relative to the processor 51, and these remote memories can be connected to the device via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0105] Input device 53 can be used to receive input digital or character information, and to generate key signal inputs related to user settings and function control of the device. Output device 54 may include display devices such as a display screen.

[0106] The processor 51 executes various functional applications and data processing of the device by running software programs, instructions and modules stored in the memory 52, thereby realizing the multi-algorithm node concurrent execution method for the training task described above.

[0107] The multi-algorithm node concurrent execution device, equipment, and computer for training tasks provided above can be used to execute the multi-algorithm node concurrent execution method for training tasks provided in any of the above embodiments, and have corresponding functions and beneficial effects.

[0108] This application embodiment also provides a storage medium for storing computer-executable instructions. When executed by a computer processor, the computer-executable instructions are used to execute a multi-algorithm node concurrent execution method for a training task as provided in the above embodiment. The multi-algorithm node concurrent execution method for a training task includes: in response to a breeding model training request, generating a training task matrix and a preprocessing cache key corresponding to the breeding model training request; determining multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependencies between the multiple branch format conversion nodes and the multiple algorithm nodes; obtaining preprocessing results that meet consistency conditions from a preset cache based on the preprocessing cache key, and inputting the preprocessing results to the corresponding branch format conversion node; when the corresponding branch format conversion node completes the conversion of the preprocessing results, determining multiple concurrent nodes among the multiple algorithm nodes based on the dependencies, the preset resource profiles of each algorithm node, and the obtained available resource data, and executing the multiple concurrent nodes.

[0109] Storage medium – any type of memory device or storage device. The term “storage medium” is intended to include: mounting media, such as CD-ROMs, floppy disks, or magnetic tape devices; computer system memory or random access memory, such as DRAM, DDR RAM, SRAM, EDO RAM, Rambus RAM, etc.; non-volatile memory, such as flash memory, magnetic media (e.g., hard disks or optical storage); registers or other similar types of memory elements, etc. Storage media may also include other types of memory or combinations thereof. Furthermore, storage media may reside in a first computer system in which a program is executed, or may reside in a different second computer system connected to the first computer system via a network (such as the Internet). The second computer system can provide program instructions to the first computer for execution. The term “storage medium” can include two or more storage media that may reside in different locations (e.g., in different computer systems connected via a network). Storage media may store program instructions (e.g., specifically implemented as a computer program) executable by one or more processors.

[0110] Of course, the computer-executable instructions provided in the embodiments of this application are not limited to the multi-algorithm node concurrent execution method for training tasks as described above, but can also execute related operations in the multi-algorithm node concurrent execution method for training tasks provided in any embodiment of this application.

[0111] The multi-algorithm node concurrent execution apparatus, device and storage medium for training tasks provided in the above embodiments can execute the multi-algorithm node concurrent execution method for training tasks provided in any embodiment of this application. For technical details not described in detail in the above embodiments, please refer to the multi-algorithm node concurrent execution method for training tasks provided in any embodiment of this application.

[0112] The above description is merely a preferred embodiment and the technical principles employed in this application. This application is not limited to the specific embodiments described herein, and various obvious changes, readjustments, and substitutions that can be made by those skilled in the art will not depart from the scope of protection of this application. Therefore, although this application has been described in detail through the above embodiments, this application is not limited to the above embodiments, and may include more other equivalent embodiments without departing from the concept of this application, the scope of which is determined by the scope of the claims.

Claims

1. A method for concurrent execution of multiple algorithm nodes in a training task, characterized in that, The method includes: In response to a breeding model training request, a training task matrix and a preprocessing cache key corresponding to the breeding model training request are generated; Determine multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependencies between the multiple branch format conversion nodes and the multiple algorithm nodes; Based on the preprocessing cache key, obtain the preprocessing result that meets the consistency condition from the preset cache, and input the preprocessing result into the corresponding branch format conversion node; When the corresponding branch format conversion node completes the conversion of the preprocessing result, multiple concurrent nodes are determined based on the dependency relationship, the preset resource profile of each algorithm node and the obtained available resource data, and the multiple concurrent nodes are executed.

2. The method for concurrent execution of multiple algorithm nodes in a training task according to claim 1, characterized in that, The preprocessing results satisfy consistency conditions, including: The actual summary value of the preprocessing result is consistent with the preset product summary value associated with the preprocessing result. The actual summary value is obtained by hashing the data file content of the preprocessing result. The preset product summary value is stored in association with the preprocessing cache key.

3. The method for concurrent execution of multiple algorithm nodes in a training task according to claim 1, characterized in that, The method further includes: If there is no preprocessing result corresponding to the preprocessing cache key in the preset cache or the consistency check of the preprocessing result fails, the genotype file in the breeding model training request is preprocessed based on the preset common preprocessing node to obtain the preprocessing result. The preprocessing includes at least one of quality control filtering, genotype filling and index generation. The preprocessing result is associated with the preprocessing cache key and saved to a preset cache.

4. The method for concurrent execution of multiple algorithm nodes in a training task according to claim 1, characterized in that, The step of determining multiple concurrent nodes among the multiple algorithm nodes based on the dependency relationship, the preset resource profile of each algorithm node, and the obtained available resource data includes: Based on the aforementioned dependency relationship, multiple executable nodes are determined from multiple algorithm nodes, and multiple concurrent nodes are selected from multiple executable nodes according to the preset resource profile of each executable node and the obtained available resource data. Accordingly, the execution of multiple concurrent nodes includes: Determine the execution priority corresponding to each executable node, and execute the multiple concurrent nodes concurrently in descending order of the preset global node concurrency limit and the execution priority.

5. The method for concurrent execution of multiple algorithm nodes in a training task according to claim 1, characterized in that, The generation of the training task matrix and preprocessing cache key corresponding to the breeding model training request includes: Parse the breeding model training request to obtain the phenotypic set, algorithm set, and genotype file; The phenotypic column set and the algorithm set are combined in Cartesian order to generate a training task matrix corresponding to the breeding model training request. Based on the file content summary information, quality control parameters, and preprocessing software version in the genotype file, a preprocessing cache key corresponding to the breeding model training request is generated.

6. The method for concurrent execution of multiple algorithm nodes in a training task according to claim 1, characterized in that, The determination of multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, and the dependency relationships between the multiple branch format conversion nodes and the multiple algorithm nodes, includes: Based on the target algorithm corresponding to each training task in the training task matrix, determine multiple algorithm nodes corresponding to each training task; Based on the target input format of each algorithm node, a branch format conversion node corresponding to each algorithm node is determined, and the dependency relationship between multiple branch format conversion nodes and multiple algorithm nodes is determined according to the correspondence between each algorithm node and each branch format conversion node.

7. The method for concurrent execution of multiple algorithm nodes in a training task according to claim 1, characterized in that, In the process of executing multiple concurrent nodes, the method further includes: Obtain the execution status of each of the concurrent nodes; If there are algorithm nodes in the execution state of failure, filter out the algorithm nodes in the failure state to obtain multiple remaining nodes; Obtain the current remaining resources, determine the executable node among the multiple remaining nodes based on the dependency relationship, the preset resource profile of each remaining node and the current remaining resources, and execute the executable node.

8. A multi-algorithm node concurrent execution device for a training task, characterized in that, The device includes: The training task generation module is used to generate a training task matrix and a preprocessing cache key corresponding to the breeding model training request in response to the breeding model training request. The dependency determination module is used to determine multiple branch format conversion nodes and multiple algorithm nodes corresponding to the training task matrix, as well as the dependency relationships between the multiple branch format conversion nodes and the multiple algorithm nodes; The preprocessing module is used to obtain the preprocessing result that meets the consistency condition from the preset cache based on the preprocessing cache key, and input the preprocessing result to the corresponding branch format conversion node; The concurrent execution module is used to determine multiple concurrent nodes among the multiple algorithm nodes based on the dependency relationship, the preset resource profile of each algorithm node and the obtained available resource data, and execute the multiple concurrent nodes when the corresponding branch format conversion node completes the conversion of the preprocessing result.

9. An electronic device, characterized in that, It includes a processor, a memory, and a program or instructions stored in the memory and executable on the processor, wherein the program or instructions, when executed by the processor, implement the steps of a multi-algorithm node concurrent execution method for a training task as described in any one of claims 1-7.

10. A readable storage medium, characterized in that, The program or instructions are stored on the readable storage medium, and when the program or instructions are executed by the processor, they implement the steps of the multi-algorithm node concurrent execution method for a training task as described in any one of claims 1-7.

Images