Algorithm project generation and access method, system, electronic device and storage medium

Abstract

This application discloses a method, system, electronic device, and storage medium for generating and accessing algorithm projects. The algorithm project access method is applied to a project terminal and includes: obtaining an algorithm project package, which includes a file directory and a resource package directory. The file directory contains several files required for the execution of each algorithm project, and these files carry different types of information about the algorithm project. The resource package directory contains installation packages for several operator models required for the execution of the algorithm project. The information of various types obtained by parsing each file in the algorithm project package is stored in storage media corresponding to each type of information. The installation packages of each operator model are stored in a storage engine, and a storage model is generated. Based on at least some types of information stored in each storage medium, tasks for the algorithm project are generated, and the corresponding storage models are called to execute the tasks. This solution can improve the efficiency of algorithm project access.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a method, system, electronic device, and storage medium for generating and accessing algorithm projects. Background Technology

[0002] In the current algorithm field, project delivery is usually completed at the project level. Algorithm projects typically require a lot of data, such as the algorithm flow and the operator models used in the flow. This results in the data being parsed and stored in a unified storage area on the project terminal. As a result, if a problem occurs during the execution of the algorithm project, the original imported algorithm project can only be deleted and a new data package can be imported, which is a rather cumbersome process. Summary of the Invention

[0003] This application provides at least one method, system, electronic device, and storage medium for generating and accessing algorithm projects.

[0004] This application provides a method for accessing algorithm projects, applied to a project terminal. The method includes: obtaining an algorithm project package, which includes a file directory and a resource package directory. The file directory contains several files required for the execution of each algorithm project, and these files carry information of different types of the algorithm project. The resource package directory contains installation packages for several operator models required for the execution of the algorithm project. The method involves parsing each file in the algorithm project package and storing the parsed information of various types into storage media in the project terminal corresponding to the information of each type. It also involves storing the installation packages of each operator model into a storage engine and generating storage models for each operator model. Based on at least some types of information stored in each storage medium, the method generates tasks for the algorithm project and calls the corresponding storage models to execute the tasks.

[0005] In the above scheme, an algorithm project package with file directories and resource package directories is constructed. Each directory contains information about different types of algorithm projects. After parsing the algorithm project package, the information of each type can be stored in its corresponding storage medium, and the algorithm model can be stored in the corresponding storage engine. Then, based on the parsed information of various types of algorithm projects, the corresponding tasks are determined and executed. In addition to importing the algorithm project into the project terminal, because the information in each file of the algorithm project package is independent, if the algorithm project needs to be updated, the information or operator model in the project terminal that needs to be updated can be updated specifically, without updating the entire algorithm project package and re-importing it into the project terminal.

[0006] In some embodiments, several files include a node orchestration file, which includes node orchestration information for each node in the algorithm project. Each file in the algorithm project package is parsed, and the parsed information of various classes is stored in the storage medium corresponding to the information of each class in the project terminal. This includes: parsing the node orchestration file to obtain the association relationship between each node and the definition information of each node; and writing the association relationship between each node and the definition information of each node into a node association graph, wherein at least some nodes in the node association graph are operator model nodes.

[0007] In the above scheme, a separate node orchestration file is set up in the algorithm project package, and the algorithm project orchestration information is stored separately in the node association graph based on the association relationship between nodes obtained by parsing the node orchestration file and the definition information of each node.

[0008] In some embodiments, the definition information of each node includes the node type of each node and the indication information of each node. The node type includes any one of the following: data source node, operator model node, database node, and computing engine node.

[0009] In the above scheme, by defining the types of nodes and the indication information of each node, it is convenient to determine the execution flow of the task according to the type of each node. Also, since the data source node in the algorithm project may call multiple data sources, the operator model node may call multiple operator models, and similarly, the database node and the computing engine node may call multiple databases and computing engines, the specific data source, operator model, database or computing engine that each node needs to use can be determined according to the indication information of each node.

[0010] In some embodiments, based on at least some types of information stored in each storage medium, tasks for algorithm projects are generated and corresponding storage models are invoked to execute the tasks, including: taking the data source node as the starting node, and based on the definition information of each node in the node association graph and the association relationship between each node, determining the branch in the node association graph where the data source node is located and taking the branch as the task; obtaining the storage model that needs to be invoked in the task from the storage engine to execute the task.

[0011] In the above scheme, after the node association graph is determined, each data source node can have multiple subsequent nodes. The data source node can be taken as the first node. Based on the connection relationship between the nodes, multiple tasks with the data source node as the first node can be determined. The storage engine corresponding to the operator model node contained in each task needs to be called to execute the task.

[0012] In some embodiments, the plurality of files include a project file, which carries parameter values ​​of global parameters in the algorithm project. The orchestration information includes parameter values ​​of parameters in at least some nodes. The method further includes: determining a reference parameter value group for each parameter based on the parameter values ​​of the plurality of parameters in the orchestration file and / or the project file. The reference parameter values ​​in the reference parameter value group for each parameter include at least one of the following: parameter values ​​of parameters carried in the orchestration file and / or the project file, parameter values ​​about the parameter generated by the project terminal, preset built-in parameter values ​​about the parameter, and parameter values ​​about the parameter input by the user; and configuring parameters for parameters in at least some nodes and / or global parameters in the node association graph using the reference parameter value groups for each parameter.

[0013] In the above scheme, after parsing the algorithm project package to obtain the parameters of each node required by the algorithm project and / or the global parameters, the reference parameter value group of each parameter is determined by combining the parameter values ​​generated by the project terminal, the built-in parameter values ​​of the parameters, and / or the parameter values ​​input by the user. This makes it easier to select parameter values ​​from the reference parameter value group for configuration. Compared with configuring parameters using only a single parameter value, the parameter configuration method provided by this scheme is more flexible and can reduce the occurrence of project running errors due to incorrect configuration of a single parameter value.

[0014] In some embodiments, the parameters in at least some nodes and / or global parameters in the node association graph are configured using the reference parameter value group of each parameter, including: performing the following steps for each parameter: determining the priority among the reference parameter values ​​in the reference parameter value group of the parameter; taking the reference parameter value in the reference parameter value group that meets the preset priority condition as the target parameter value; and configuring each parameter using each target parameter value.

[0015] In the above scheme, by setting priorities for the reference parameter values ​​of each parameter, the parameter values ​​can be determined according to each priority, thereby making the determined parameter values ​​more accurate.

[0016] In some embodiments, determining the priority among reference parameter values ​​in a reference parameter value group includes: determining the category to which the parameter belongs; determining a priority sorting method corresponding to the category to which the parameter belongs from several priority sorting methods; and determining the priority among reference parameter values ​​in a reference parameter value group according to the priority sorting method corresponding to the category to which the parameter belongs.

[0017] In the above scheme, different categories of parameters can be set with different priority sorting methods, so that the priority sorting methods set for different categories of parameters are the same or different. Compared with setting the same priority sorting method for different types of parameters, this scheme can make the parameter values ​​determined by each parameter more accurate.

[0018] In some embodiments, several files include a scheduling file, which includes the offset type and offset of the start time of the algorithm project, and the offset type and offset of the stop time. The method further includes: determining the start time of the algorithm project based on the offset type and offset of the start time, and determining the stop time of the algorithm project based on the offset type and offset of the stop time; and registering tasks for scheduled execution based on the start time and stop time of the algorithm project.

[0019] In the above solution, some scenarios may require running the algorithm project within a specific time interval. Therefore, the offset type and offset amount of the start and end running times can be set to achieve scheduled running of the algorithm project.

[0020] In some embodiments, the files further include an operator information file, which includes the identifier and version number of each operator model. The identifier and version number of each operator model parsed from the operator information file are written into the operator information table of the project terminal. The method further includes: receiving an update message, which includes the new version number of the operator model to be updated and the acquisition path of the new version installation package; acquiring the installation package of the new version of the operator model to be updated based on the acquisition path of the new version of the operator model to be updated; and updating the operator model to be updated using the installation package of the new version of the operator model to be updated and updating the version number of the operator model to be updated in the operator information table in response to the new version number of the operator model to be updated being higher than the version number of the operator model to be updated in the operator information table.

[0021] In the above scheme, the current update of algorithm projects is still at the stage of generating a new algorithm project package and replacing the old algorithm project package with the new algorithm project package. This scheme sends an update message to the project terminal and includes the acquisition path of the new version installation package of the operator model to be updated in the update message. This allows the project terminal to obtain the new version installation package according to the acquisition path and update the operator model to be updated.

[0022] In some embodiments, the files further include an operator information file, which includes the identifier and version number of each operator model. The identifier and version number of each operator model parsed from the operator information file are written into the operator information table of the project terminal. The algorithm project access method further includes: receiving the identifier, version number, and installation package of a new operator model imported from the API interface of the project terminal; comparing the identifier of the new operator model with the identifiers of existing operator models in the operator information table to determine the old operator model corresponding to the new operator model; and updating the old operator model and the version number of the old operator model in the operator information table in response to the new operator model's version number being higher than the version number of the old operator model in the operator information table using the installation package of the new operator model.

[0023] In the above scheme, the operator model can also be updated by receiving the identifier of the imported new operator model and the installation package through the API interface, making the operator model update method more diversified.

[0024] In some embodiments, the algorithm project includes several tasks, which are run in segments. The access method for the algorithm project further includes: obtaining log data, running data and running environment parameters of each task generated during the execution of each task in the algorithm project; and storing the obtained log data, running data and running environment parameters of each task in the corresponding storage medium in the project terminal.

[0025] In the above scheme, by collecting log data, running data and running environment parameters generated during the execution of each task in the algorithm project, it is convenient to trace the execution process of the algorithm project in the future.

[0026] In some embodiments, the project terminal includes an algorithm project access system, and the algorithm project access method is executed by the algorithm project access system. The algorithm project access method further includes: in response to the existence of a failed task in the algorithm project, sending relevant data of the failed task to a preset receiver, the task-related data including log data, running data, running environment parameters, and the installation package of the operator model used in the failed task; receiving debugging data sent by the preset receiver, the debugging data including update parameters of the operator model, update parameters of the running environment parameters, and / or update parameters of the algorithm project access system; and adjusting the operator model, running environment parameters, and / or the algorithm project access system corresponding to the failed task based on the received debugging data.

[0027] In the above scheme, by sending the relevant data of the failed task to a preset recipient, and having the preset recipient re-simulate the task execution process based on the relevant data, the cause of the task failure can be determined, and targeted debugging data can be proposed, so that the project terminal can make corresponding adjustments after receiving the debugging data.

[0028] In some embodiments, the method for accessing an algorithm project further includes: displaying relevant information about the algorithm project on the display interface of the project terminal, wherein the relevant information about the algorithm project includes the access status and / or running status of the algorithm project.

[0029] In the above solution, displaying relevant information about the algorithm project on the project execution display interface allows users to easily understand the access status and / or operation status of the algorithm project in a timely manner.

[0030] This application provides a method for generating algorithm projects, applied to an algorithm project generation device. The method includes: obtaining different types of information required for executing the algorithm project and installation packages of several operator models; generating an algorithm project package based on the different types of information and the installation packages of several operator models. The algorithm project package includes a file directory and a resource package directory. The file directory contains several files required for executing the algorithm project, and these files carry different types of information about the algorithm project. The resource package directory contains installation packages of several operator models required for executing the algorithm project. The algorithm project package can be imported into the project terminal after being obtained by the project terminal using any of the above-mentioned algorithm project access methods.

[0031] In the above scheme, an algorithm project package with file directories and resource package directories is constructed. Each directory contains information about different types of algorithm projects. After parsing the algorithm project package, the information of each type can be stored in its corresponding storage medium, and the algorithm model can be stored in the corresponding storage engine. Then, based on the parsed information of various types of algorithm projects, the corresponding tasks are determined and executed. In addition to importing the algorithm project into the project terminal, because the information in each file of the algorithm project package is independent, if the algorithm project needs to be updated, the information or operator model in the project terminal that needs to be updated can be updated specifically, without updating the entire algorithm project package and re-importing it into the project terminal.

[0032] In some embodiments, an algorithm project package is generated based on different types of information and installation packages of several operator models, including: mapping the obtained information of various types to files in the file directory of the algorithm project package, and mapping the installation packages of each operator model to the resource package directory.

[0033] In the above scheme, by fixing the structure of the algorithm project package and mapping each piece of information to a separate file, the project terminal can complete the access of the algorithm project based on the algorithm project package containing the file directory and resource package directory.

[0034] This application provides an algorithm project access system, comprising: an algorithm project receiving module for acquiring an algorithm project package, the algorithm project package including a file directory and a resource package directory, the file directory including several files required for the execution of each algorithm project, the several files carrying different types of information of the algorithm project, and the resource package directory including an installation package containing several operator models required for the execution of the algorithm project; a parsing module for parsing each file in the algorithm project package and storing the parsed information of various types into storage media corresponding to the information of various types in the project terminal, and storing the installation packages of each operator model into the storage engine and generating storage models of each operator model; and a running module for generating tasks of the algorithm project based on at least some types of information stored in each storage medium and calling the corresponding storage models to execute the tasks.

[0035] This application provides an algorithm project generation system, applied to an algorithm project generation device. The system comprises: a data receiving module for acquiring different types of information required for executing the algorithm project and installation packages of several operator models; and an algorithm project package generation module for generating an algorithm project package based on the different types of information and the installation packages of several operator models. The algorithm project package includes a file directory and a resource package directory. The file directory contains several files required for executing the algorithm project, each file carrying different types of information about the algorithm project. The resource package directory contains installation packages of several operator models required for executing the algorithm project. The algorithm project package can be imported into the project terminal via an access system after being acquired by the project terminal.

[0036] This application provides an electronic device, including a memory and a processor, wherein the processor is used to execute program instructions stored in the memory to implement the above-described algorithm project access method or the above-described algorithm project generation method.

[0037] This application provides a computer-readable storage medium storing program instructions thereon, which, when executed by a processor, implement the access method or the generation method of the aforementioned algorithm project.

[0038] In the above scheme, an algorithm project package with file directories and resource package directories is constructed. Each directory contains information about different types of algorithm projects. After parsing the algorithm project package, the information of each type can be stored in its corresponding storage medium, and the algorithm model can be stored in the corresponding storage engine. Then, based on the parsed information of various types of algorithm projects, the corresponding tasks are determined and executed. In addition to importing the algorithm project into the project terminal, because the information in each file of the algorithm project package is independent, if the algorithm project needs to be updated, the information or operator model in the project terminal that needs to be updated can be updated specifically, without updating the entire algorithm project package and re-importing it into the project terminal.

[0039] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit this application. Attached Figure Description

[0040] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with this application and, together with the specification, serve to explain the technical solutions of this application.

[0041] Figure 1 This is a flowchart illustrating the access method for algorithm projects provided in some embodiments of this application;

[0042] Figure 2 This is a schematic diagram of the structure of the algorithm project package provided in some embodiments of this application;

[0043] Figure 3 This is another flowchart illustrating the algorithm project access method provided in some embodiments of this application;

[0044] Figure 4 This is provided by some embodiments of this application. Figure 3 A schematic diagram of the sub-process of step S22;

[0045] Figure 5 This is a first flowchart illustrating the operator model update method provided in some embodiments of this application;

[0046] Figure 6 This is a second flowchart illustrating the operator model update method provided in some embodiments of this application;

[0047] Figure 7 This is a flowchart illustrating the algorithm project generation method provided in some embodiments of this application;

[0048] Figure 8 These are schematic diagrams illustrating the interaction between a cloud-based virtual machine and an edge device, provided in some embodiments of this application.

[0049] Figure 9 This is another flowchart illustrating the algorithm project access method provided in some embodiments of this application;

[0050] Figure 10 This is a schematic diagram of the structure of an embodiment of the access system for the algorithm project of this application;

[0051] Figure 11 This is a schematic diagram of the structure of an embodiment of the generation system for the algorithm project of this application;

[0052] Figure 12 This is a schematic diagram of the structure of an embodiment of the electronic device of this application;

[0053] Figure 13 This is a schematic diagram of the structure of an embodiment of the computer-readable storage medium of this application. Detailed Implementation

[0054] The embodiments of this application will now be described in detail with reference to the accompanying drawings.

[0055] In the following description, specific details such as particular system architectures, interfaces, and technologies are presented for illustrative purposes rather than for limiting purposes, in order to provide a thorough understanding of this application.

[0056] In this document, the term "and / or" is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Additionally, the character " / " generally indicates that the preceding and following related objects have an "or" relationship. Furthermore, "many" in this document means two or more. Moreover, the term "at least one" in this document means any combination of at least two of any one or more of a plurality of objects. For example, including at least one of A, B, and C can mean including any one or more elements selected from the set consisting of A, B, and C.

[0057] Currently, if problems arise or updates are needed during algorithm project execution after importing the algorithm model into the project terminal, a new algorithm project package must be generated and then re-imported into the project terminal, which is a relatively cumbersome process.

[0058] Therefore, this solution provides an algorithm project package. Different types of information required for the execution of the algorithm project are stored in different files under the file directory of the algorithm project, and the installation package of the operator model is isolated from each file. After the project terminal parses the algorithm project, it stores the different types of information obtained from the parsing in the corresponding storage media of the terminal project, and also stores the installation package of the operator model in the storage engine and generates the corresponding storage model. This allows the algorithm project to update the corresponding information in the storage media directly if there is a need to update a certain type of information, or to update the operator model directly in the storage engine if an update is needed, without having to regenerate the algorithm project package.

[0059] Please see Figure 1 , Figure 1 This is a flowchart illustrating an embodiment of the access method for the algorithm project in this application. For example... Figure 1 As shown, the access method for the algorithm project includes: Step S11: Obtain the algorithm project package. The algorithm project package includes a file directory and a resource package directory. The file directory contains several files required for the execution of each algorithm project, and these files carry information of different types of algorithm projects. The resource package directory contains installation packages for several operator models required for the execution of the algorithm project. Step S12: Parse each file in the algorithm project package, and store the parsed information of various types into the storage medium corresponding to the information of each type in the project terminal. Also, store the installation packages of each operator model into the storage engine and generate the storage model of each operator model. Step S13: Based on at least some types of information stored in each storage medium, generate the task of the algorithm project and call the corresponding storage model to execute the task.

[0060] The project terminal can be an edge device or a cluster device. In some application scenarios, the algorithm project can be a battery algorithm project, and the project terminal can be a device including a battery, which can be a power battery or an energy storage battery; that is, the project terminal can be an energy storage device or a power device. Methods for obtaining the algorithm project package include, but are not limited to, importing via API interface, importing via the project terminal's display interface, and importing via USB flash drive. The algorithm project package can contain several files from one or more algorithm projects, and different algorithm projects may share common algorithm models or common types of information. Optionally, files carrying the same information from different algorithm projects can be placed in the same file, or the same file can contain multiple sub-files, with different sub-files corresponding to different algorithm projects. Different types of information may include at least one of the following: node orchestration information and the definition information of each node, operator model definition information, algorithm project related information, and scheduling information. For an example, please refer to [link to example]. Figure 2The file directory includes several files, including project files, operator information files, node orchestration files, and scheduling files. Node orchestration information can include the relationships between nodes. Algorithm project information can include the algorithm project identifier, algorithm project description, global parameter definitions, etc. The method for parsing each file in the algorithm project package and storing the parsed information of various types in the corresponding storage media in the project terminal can be to set a corresponding file parsing method for each file and parse each file according to its corresponding parsing method. The storage media can be data tables or data graphs. For example, the information parsed from the project files and operator information files can be stored in their respective data tables, and the information parsed from the node orchestration files can be stored in the corresponding node association graph. Alternatively, scheduling information can be stored in the corresponding data table. Scheduling information can also be directly used for task registration after parsing for subsequent scheduled task execution. The storage engine can be MinIO, HDFS, etc. In some application scenarios, different resources are stored in different resource package directories. For example, the installation package of the operator model is stored in a type 1 resource package directory. The algorithm project package may also include a type 2 resource package directory. The type 2 resource package directory may also include the installation package of the computing engine required to run the algorithm project. The computing engine is stored in the storage engine of the project terminal. The installation package corresponding to the computing engine may include the runtime JAR file of the computing engine and the configuration package of the computing engine. For example, if the computing engine is Spark, the installation package of the computing engine may include the runtime JAR file of Spark. The storage medium of the project terminal may include a storage engine, such as Minio, HDFS, etc. When each task in the algorithm project is running, it can pull the relevant resource package from the storage engine for processing. The above method of generating tasks for the algorithm project and calling the corresponding storage model to execute the tasks based on at least some types of information stored in each storage medium can be based on generating tasks based on node association graphs, and then calling the corresponding storage model according to the operator model required by the task.

[0061] In the above scheme, an algorithm project package with file directories and resource package directories is constructed. Each directory contains information about different types of algorithm projects. After parsing the algorithm project package, the information of each type can be stored in its corresponding storage medium, and the algorithm model can be stored in the corresponding storage engine. Then, based on the parsed information of various types of algorithm projects, the corresponding tasks are determined and executed. In addition to importing the algorithm project into the project terminal, because the information in each file of the algorithm project package is independent of each other, if the algorithm project needs to be updated, the information or operator model in the project terminal that needs to be updated can be updated specifically, without updating the entire algorithm project package and re-importing it into the project terminal.

[0062] In some embodiments, several files include a node arrangement file, which includes node arrangement information for each node in the algorithm project. Each file in the algorithm project package is parsed, and the parsed information of various classes is stored in the storage medium corresponding to the information of each class in the project terminal. This includes: parsing the node arrangement file to obtain the association relationship between each node and the definition information of each node; writing the association relationship between each node and the definition information of each node into a node association graph, wherein at least some nodes in the node association graph are operator model nodes.

[0063] The node orchestration file can be parsed using a pre-defined parsing method to obtain the node orchestration information for each node. For a given node, its orchestration information can include the identifiers of its predecessor and successors. In other words, the node orchestration information represents the relationships between nodes. The algorithm's execution flow can include the execution order of each node. After the execution order of each node is determined, it is executed according to that order, thus running the algorithm. A node association graph can be obtained based on the identifiers of each node's predecessor and successors. A node can have one or more predecessor nodes, and multiple successors. For example, a branch in the node association graph could be first node → second node → third node. Writing the relationships between nodes and the definition information of each node into the node association graph can be considered as initializing or updating the pre-defined node association graph.

[0064] In the above scheme, a separate node orchestration file is set up in the algorithm project package, and the association relationship between nodes and the definition information of each node are obtained by parsing the node orchestration file to determine the separate storage of the algorithm project orchestration information in the node association graph.

[0065] In some embodiments, the definition information of each node includes the node type of each node and the indication information of each node. The node type includes any one of the following: data source node, operator model node, database node, and computing engine node.

[0066] For example, a branch in a Directed Acyclic Graph (DAG) could be: Data Source A → Operator Model a → Operator Model b → Operator Model c → Computation Engine Node → Database. The DAG can be considered the execution flow of an algorithm project, with arrows between nodes representing the execution order. A data source in the DAG can have multiple subsequent operator model nodes, and an operator model node may have multiple preceding data source nodes. Each node type includes several types of objects. The indicator information of each node is used to indicate the corresponding objects under its node type. The various objects under a data source node can be different data sources. For example, they can be considered data sources needed during project execution, such as temperature, voltage, current, and impedance data. Alternatively, the objects under a data source node can be considered the storage location of the data source or objects input to the data source. For example, a data source node can include, but is not limited to, voltage sampling circuits, temperature sampling circuits, current sampling circuits, and impedance sampling circuits. A data source node can also be the output data of a computation engine node, which can occupy one data source node. The objects under the operator model node can be different operator models, such as a model that uses temperature as input data and performs calculations, a model that uses voltage as input data and performs calculations, or a model that uses current as input data and performs calculations. The objects under the database node can be different databases, and the objects under the computing engine node can be different computing engines. The execution flow can be that the computing engine calls the data indicated by the data source node as input data, calls the operator model indicated by the operator model node to process the input data, and then stores the processed result in the database indicated by the database node.

[0067] A Directed Acyclic Graph (DAG) can be used to describe the relationships between operators. The DAG also needs data sources, filtering conditions, databases, and other non-operator information to form the overall project workflow. The orchestration file typically requires two protocols. The first protocol is the node protocol, which describes the information of each node (each node in the DAG). For example, the node protocol includes the following fields: Code, ProcessCode, ProcessVersion, Display, NodeType, and NodeParams. The Code field represents the node identifier; the ProcessCode field represents the identifier of the algorithm project it belongs to; the ProcessVersion field represents the version of the algorithm project; the Display field represents some display information of the node; the NodeType field represents the type of node, such as a data source node, operator model node, database node, or computation engine node; and the NodeParams field represents node parameters, such as the specific object the node points to. The second protocol includes the node-to-node relationship protocol, which may include the following fields: ProcessCode: identifier of the algorithm project it belongs to; ProcessVersion: version of the algorithm project; PreNodeCode: identifier of the preceding node; PostNodeCode: identifier of the following node.

[0068] In the above scheme, by defining the types of nodes and the indication information of each node, it is convenient to determine the execution flow of the task according to the type of each node. Also, since the data source node in the algorithm project may call multiple data sources, the operator model node may call multiple operator models, and similarly, the database node and the computing engine node may call multiple databases and computing engines, the specific data source, operator model, database or computing engine that each node needs to use can be determined according to the indication information of each node.

[0069] In some embodiments, based on at least some types of information stored in each storage medium, tasks for algorithm projects are generated and corresponding storage models are invoked to execute the tasks, including: taking the data source node as the starting node, and based on the definition information of each node in the node association graph and the association relationship between each node, determining the branch in the node association graph where the data source node is located and taking the branch as the task; obtaining the storage model that needs to be invoked in the task from the storage engine to execute the task.

[0070] For example, in the node association graph, starting from the first node, subsequent nodes are searched sequentially until no subsequent node can be found. The nodes between the starting node and one of the last nodes are then considered a branch of the data source node in the node association graph, and this branch is treated as a task. If the starting node corresponds to multiple last nodes, each node between the starting and last nodes can be considered a task, meaning different data processing can be performed on the data output from the data source node. If the relationships between nodes in the node association graph are complex, multiple tasks can be determined in this way. Alternatively, the algorithm project can include a runtime file indicating the nodes required for each task. The execution flow of the task can then be determined from the node association graph based on the relationships between the indicated nodes. For instance, the running nodes required for task execution can be calculated using the node definition information and the relationships between nodes in the node association graph. Corresponding running instances are then generated and submitted to the corresponding task executor. The task executor retrieves the corresponding resource files from the resource storage medium and completes the node execution.

[0071] In the above scheme, after the node association graph is determined, each data source node can have multiple subsequent nodes. The data source node can be taken as the first node. Based on the connection relationship between the nodes, multiple tasks with the data source node as the first node can be determined. The storage engine corresponding to the operator model node contained in each task needs to be called to execute the task.

[0072] Please see Figure 3 The system comprises several files, including a project file containing global parameter values ​​for the algorithm project. The orchestration information includes parameter values ​​for parameters in at least some nodes. The method for accessing the algorithm project includes: Step S21: Several files include a project file containing global parameter values ​​for the algorithm project. The orchestration information includes parameter values ​​for parameters in at least some nodes. The reference parameter value group for each parameter includes at least one of the following: parameter values ​​carried in the orchestration file and / or project file, parameter values ​​generated by the project terminal, preset built-in parameter values, and user-input parameter values. Step S22: Using the reference parameter value groups for each parameter, configure the parameters in at least some nodes and / or the global parameters in the node association graph.

[0073] Each parameter's reference parameter value group includes both the reference parameter value group for parameters within a node and the global reference parameter value group. This means that parameters within a node can be configured, as can global parameters. The node parameters required by the algorithm project include, but are not limited to, execution time parameters, data processing parameters (e.g., data preprocessing methods), and other project-specific parameters. Different nodes may require different parameters. Global parameters refer to configuration items that are common throughout the project and affect multiple nodes. Global parameters include, but are not limited to, environment configuration parameters (e.g., log storage location, data file storage location), system configuration parameters (e.g., parallel processing methods, runtime environment parameters), log configuration parameters (e.g., log level, log format, and log file naming conventions), and other necessary configurations. Parameter values ​​generated by the project terminal can be considered as parameter values ​​generated by scripts in the algorithm project's access system, such as parameters generated by a parameter engine. In some application scenarios, different parameters correspond to different scripts. The preset built-in parameter values ​​can be considered as the parameter values ​​built into the project terminal. User-input parameter values ​​can be considered as those entered by the user through the API interface or the project terminal's display interface. These built-in parameters can be stored in an SQL / Nacos database. The categories and / or number of reference parameter values ​​for different parameters can be the same or different. For example, some parameters' reference parameter values ​​include those carried in the orchestration file and / or project file, and parameter values ​​generated by the project terminal; others include those carried in the orchestration file and / or project file, and user-input parameter values. The method described above, which uses the reference parameter value groups of each parameter to configure parameters in at least some nodes and / or global parameters in the node association graph, can be achieved by selecting a parameter value from each parameter's reference parameter value group as the parameter's parameter value. After the parameters are configured, the algorithm project can be run.

[0074] In the above scheme, after parsing the algorithm project package to obtain the parameters of each node required by the algorithm project and / or the global parameters, the reference parameter value group of each parameter is determined by combining the parameter values ​​generated by the project terminal, the built-in parameter values ​​of the parameters, and / or the parameter values ​​input by the user. This makes it easier to select parameter values ​​from the reference parameter value group for configuration. Compared with configuring parameters using only a single parameter value, the parameter configuration method provided by this scheme is more flexible and can reduce the occurrence of project running errors due to incorrect configuration of a single parameter value.

[0075] In some embodiments, please refer to Figure 4Step S22 above may include the following steps: Perform steps S221 to S222 on each parameter, then determine the target parameter value for each parameter, and finally configure each parameter using step S223. Step S221: Determine the priority among the reference parameter values ​​in the parameter's reference parameter value group. Step S222: Use the reference parameter value in the reference parameter value group that meets the preset priority condition as the target parameter value. Step S223: Configure each parameter using each target parameter value.

[0076] Within this framework, the number of reference parameter values ​​in different parameter reference parameter value groups can be the same or different. The categories of reference parameter values ​​within different parameter reference parameter value groups can be the same or different. The priority of each reference parameter value within a different parameter reference parameter value group can be the same or different. The preset priority condition can be the highest priority or a relatively early priority; for example, if a parameter includes four parameters, the reference parameter values ​​with relatively early priority could be the highest and second-highest priority reference parameter values. Optionally, the priority sorting method can be: user-input parameter values ​​> parameter engine-generated parameters > built-in parameters from the configuration center > built-in parameters from files > built-in parameters from tables > dynamic built-in parameters > constant parameters. Here, built-in parameters from files can be parameters directly read from the orchestration file and / or project file, while built-in parameters from tables can be parameters read from the database after parsing and storing the orchestration file and / or project file. This reduces the occurrence of parameter value reading errors due to errors in the database storage process. The constants here can be the preset built-in parameter values ​​for the parameters mentioned above. The built-in parameters of configuration centers (such as Spring Cloud Config, Consul, etcd, etc.) largely depend on the specific configuration center implementation. Different configuration centers may have different built-in parameters and configuration items.

[0077] In some application scenarios, taking the target parameter value as a parameter value directly input by the user as an example: for example, if a time parameter ${today} is configured in the node, when the user executes, the parameter today can be passed in, such as: today = "2024-08-29 00:00:00", then the parameter engine will replace ${today} in the parameter node with the passed parameter.

[0078] In some application scenarios, taking the target parameter value as the example of script generation, in some battery-related scenarios, the parameters need to contain some logic, such as needing to perform some offset operations on the time. In this case, some script processing can be performed on this part of the parameter. For example: time = "${string_to_timestamp(date_to_string(date_offset(string_to_date(today,'yyyy-MM-ddHH:mm:ss'),'hour',-1),'yyyy-MM-dd HH:00:00'),'yyyy-MM-dd HH:mm:ss')}". This script means to take the time one hour before the current time. When executed, the parameter engine will execute this script, calculate one hour ahead of the current execution time to generate the final time and fill it into this parameter.

[0079] In the above scheme, by setting priorities for the reference parameter values ​​of each parameter, the parameter values ​​can be determined according to each priority, thereby making the determined parameter values ​​more accurate.

[0080] In some embodiments, determining the priority among reference parameter values ​​in a reference parameter value group includes: determining the category to which the parameter belongs; determining a priority sorting method corresponding to the category to which the parameter belongs from several priority sorting methods; and determining the priority among reference parameter values ​​in a reference parameter value group according to the priority sorting method corresponding to the category to which the parameter belongs.

[0081] Considering that some parameters require priority to user-inputted parameters, while other environmental parameters require the use of built-in parameters from the access system to avoid potential project malfunctions, different types of parameters can be categorized. Different categories can have different priority ranking methods, and parameters within the same category can use the same priority ranking method. In some embodiments, a correspondence between the parameter's category and its priority ranking method can be pre-established. Based on this correspondence, the priority ranking method among the reference parameter values ​​for each category can be determined.

[0082] In the above scheme, different categories of parameters can be set with different priority sorting methods, so that the priority sorting methods set for different categories of parameters are the same or different. Compared with setting the same priority sorting method for different types of parameters, this scheme can make the parameter values ​​determined by each parameter more accurate.

[0083] In some embodiments, several files include a scheduling file, which includes the offset type and offset of the start time of the algorithm project, and the offset type and offset of the stop time. The method may include the following steps: determining the start time of the algorithm project based on the offset type and offset of the start time, and determining the stop time of the algorithm project based on the offset type and offset of the stop time; registering tasks based on the start time and stop time of the algorithm project for scheduled execution.

[0084] Optionally, an algorithm project may include several tasks, with different task execution flows and execution times. The offset type and amount of the algorithm project's start and stop execution times can respectively include the offset type and amount of each task's start and stop execution times. The offset type can be a unit of time, such as seconds, minutes, hours, days, weeks, months, years, etc., and the offset amount can be a specific number. For example, if the start execution time offset type is hours and the offset amount is 4, it means that after the preset start time, execution will be delayed by 4 hours. Similarly, if the stop execution time offset type is hours and the offset amount is 4, it means that after the preset stop time, execution will be delayed by 4 hours. By setting the offset type and amount of the start and end execution times, tasks can be registered, facilitating scheduled execution of tasks—that is, registering and starting tasks. For example, the scheduling file mainly carries the project's scheduling information, which may include the following fields: Cron, such as 0001 / 1*? ; Scheduled task expression; StartOffsetType: Start time offset type (e.g., hours, days, months, etc.); StartOffset: Start time offset; EndOffsetType: End time offset type (e.g., hours, days, months, etc.); EndOffset: End time offset.

[0085] In the above solution, some scenarios may require running the algorithm project within a specific time interval. Therefore, the offset type and offset amount of the start and end running times can be set to achieve scheduled running of the algorithm project.

[0086] In some embodiments, please refer to Figure 5Several files also include operator information files, which contain the identifiers and version numbers of each operator model. The identifiers and version numbers of each operator model parsed from the operator information files are written into the operator information table of the project terminal. The algorithm project access method also includes: Step S31: Receiving an update message. The update message includes the new version number of the operator model to be updated and the acquisition path of the new version installation package. Step S32: Based on the acquisition path of the new version of the operator model to be updated, obtain the installation package of the new version of the operator model to be updated. Step S33: In response to the fact that the new version number of the operator model to be updated is higher than the version number of the operator model to be updated in the operator information table, update the operator model to be updated using the installation package of the new version of the operator model to be updated and update the version number of the operator model to be updated in the operator information table.

[0087] The update message can be sent by the algorithm platform used by the user. After the project execution device is connected to the algorithm platform, it can receive update messages sent by the algorithm platform. The access system retrieves the installation package of the new version of the corresponding operator model according to the acquisition path and uploads it to the corresponding storage medium of the project terminal.

[0088] In some application scenarios, considering that multiple installation packages for operator models may be available through the acquisition path, the update message may include, in addition to the acquisition path for the new version installation package, the identifier of the operator model to be updated, the version number of the new version operator model, the version number of the operator model to be updated, the project identifier of the algorithm project to which the operator model to be updated belongs, the standardized description of the operator model, and the update instance. For example, after receiving the update message, the access system retrieves the corresponding operator model installation package using the operator identifier, the version number of the new version operator model, and the acquisition path for the new version installation package, and uploads it to the corresponding storage medium on the project terminal. If the obtained operator model version is lower than the existing version, no update is performed or a prompt is issued. Upon receiving confirmation to continue the update instruction, the existing operator model is updated using the old version operator model, and the version number of the operator model in the operator information table is updated synchronously.

[0089] In the above scheme, the current update of algorithm projects is still at the stage of generating a new algorithm project package and replacing the old algorithm project package with the new algorithm project package. This scheme sends an update message to the project terminal and includes the acquisition path of the new version installation package of the operator model to be updated in the update message. This allows the project terminal to obtain the new version installation package according to the acquisition path and update the operator model to be updated.

[0090] In some embodiments, the files also include an operator information file, which includes the identifier and version number of each operator model. The identifier and version number of each operator model parsed from the operator information file are written into the operator information table of the project terminal. Please refer to [link to relevant documentation]. Figure 6 The method for updating operator models in the algorithm project access method may also include the following steps: Step S41: Receive the identifier, version number, and installation package of the new operator model imported from the project terminal's API interface. Step S42: Compare the identifier of the new operator model with the identifiers of existing operator models in the operator information table to determine the old operator model corresponding to the new operator model. Step S43: In response to the new operator model's version number being higher than the old operator model's version number in the operator information table, update the old operator model using the new operator model's installation package and update the old operator model's version number in the operator information table.

[0091] Specifically, the identifier of the new operator model can be compared with the identifiers of existing operator models in the operator information table. After determining the old operator model corresponding to the new operator model, the original operator model can be directly updated using the received new installation package. In some application scenarios, in addition to the identifier of the new operator model and the installation package, the API interface may also include the version number of the new version of the installation package. After determining the old operator model based on the identifier, the version numbers of the new model and the old model can be compared. If the version number of the new model is newer than the version number of the old model, the installation package of the new operator model is used to update the old operator model. Otherwise, the installation package of the new operator model is not used to update the old operator model or a prompt message is issued. Upon receiving a confirmation instruction to continue the update, the old version of the operator model is used to update the existing operator model, and the version number of the operator model in the operator information table is updated synchronously.

[0092] In the above scheme, the operator model can also be updated by receiving the identifier of the imported new operator model and the installation package through the API interface, making the operator model update method more diversified.

[0093] In some embodiments, the algorithm project includes several tasks, which are run in segments. The access method for the algorithm project further includes: acquiring log data, runtime data, and runtime environment parameters generated during the execution of each task in the algorithm project; and storing the acquired log data, runtime data, and runtime environment parameters of each task in the corresponding storage medium in the project terminal.

[0094] The storage medium can be a log storage medium. A task management unit can be compiled into the access system. After a task starts, the task management unit can monitor the logs of the currently running task. For example, an algorithm project might include a fault detection task using voltage as the data source and a thermal management task using temperature as the data source; the fault detection task and the thermal management task are run in segments. Running data can include the task's input data and execution results. Running environment parameters can be environmental parameters within the current project terminal, such as the terminal's operating time. In other embodiments, any parameters related to task execution, such as the installation package of the operator model used during task execution, can also be recorded. The relevant information about task execution is statistically analyzed and archived, so that subsequent statistical and archived information can be used for troubleshooting online issues.

[0095] In the above scheme, by collecting log data, running data and running environment parameters generated during the execution of each task in the algorithm project, it is convenient to trace the execution process of the algorithm project in the future.

[0096] In some embodiments, the project terminal includes an algorithm project access system, and the algorithm project access method is executed by the algorithm project access system. The algorithm project access method further includes: in response to the existence of a failed task in the algorithm project, sending relevant data of the failed task to a preset receiver, the task-related data including log data, running data, running environment parameters, and the installation package of the operator model used in the failed task; receiving debugging data sent by the preset receiver, the debugging data including update parameters of the operator model, update parameters of the running environment parameters, and / or update parameters of the algorithm project access system; and adjusting the operator model, running environment parameters, and / or the algorithm project access system corresponding to the failed task based on the received debugging data.

[0097] Optionally, the preset receiver can be a cloud-based virtual machine. After receiving the task-related data, the cloud-based virtual machine can simulate the project terminal environment and re-execute the task on the cloud-based virtual machine, thereby analyzing which parameters are problematic and causing the task to fail. For example, errors in parameters of the algorithm project's access system, runtime environment parameters, or operator model parameters may lead to task errors. Therefore, after receiving debugging data from the preset receiver, the relevant parameters can be updated. Debugging on a cloud-based virtual machine makes troubleshooting the causes of task failures more efficient.

[0098] In the above scheme, by sending the relevant data of the failed task to a preset recipient, and having the preset recipient re-simulate the task execution process based on the relevant data, the cause of the task failure can be determined, and targeted debugging data can be proposed, so that the project terminal can make corresponding adjustments after receiving the debugging data.

[0099] In some embodiments, the method for accessing an algorithm project further includes: displaying relevant information about the algorithm project on the display interface of the project terminal, wherein the relevant information about the algorithm project includes the access status and / or running status of the algorithm project.

[0100] For example, the display interface can show information such as the access progress of the algorithm project, the update progress of parameters such as the operator model, the running progress, and whether the running is normal.

[0101] In the above solution, displaying relevant information about the algorithm project on the project execution display interface allows users to easily understand the access status and / or operation status of the algorithm project in a timely manner.

[0102] Please see Figure 7 This application provides a method for generating algorithm projects. It is applied to an algorithm project generation device. The method for generating algorithm projects may include the following steps: Step S51: Obtain different types of information required to execute the algorithm project and installation packages of several operator models. Step S52: Based on the different types of information and the installation packages of several operator models, generate an algorithm project package. The algorithm project package includes a file directory and a resource package directory. The file directory contains several files required for executing the algorithm project, and these files carry different types of information about the algorithm project. The resource package directory contains installation packages of several operator models required for executing the algorithm project. The algorithm project package can be obtained by the project terminal and imported into the project terminal using any of the above-mentioned algorithm project access methods.

[0103] The algorithm project generation system can be an algorithm platform. The algorithm project generation device can be a terminal or a server. Different types of information may include at least one of the following: node orchestration information and the definition information of each node, operator model definition information, algorithm project related information, and scheduling information. For example, please refer to... Figure 2The file directory includes several files, including project files, operator information files, orchestration files, and scheduling files. Node orchestration information can include the relationships between nodes. Algorithm project information can include the algorithm project identifier, algorithm project description, global parameter definitions, etc. One way to obtain the different types of information required to execute the algorithm project is to obtain the DAG graph of the algorithm project. This DAG graph includes node orchestration information, node definition information, operator model definition information, algorithm project information, and scheduling information. For example, each node in the DAG graph includes node orchestration information, definition information, the identifier of the project to which the node belongs, and other project-related information. If the node is an operator model node, it can also include the identifier and version of the operator model that the node needs to call; if the node is a computing engine node, it can also include the identifier of the computing engine that the node needs to call. Of course, the blank areas in the DAG graph can also carry the algorithm project's scheduling information. In other words, all types of information required by the algorithm project can be written into this DAG graph. Based on different types of information and installation packages of several operator models, the algorithm project package can be generated by mapping various types of information to different files in the algorithm project package, or by providing templates for different files in the algorithm project generation system, allowing users to input corresponding information into each template, and then combining the user-input information with the templates to obtain different files.

[0104] In some embodiments, an algorithm project package is generated based on different types of information and installation packages of several operator models, including: mapping the obtained information of various types to files in the file directory of the algorithm project package, and mapping the installation packages of each operator model to the resource package directory.

[0105] For example, operator information can be mapped to operator information files, project information to project files, scheduling information to scheduling files, and orchestration information to orchestration files. Exemplarily, different types of information can be identified in the aforementioned DAG graph. Specific identification methods could include using keywords or key phrases, or identifying paragraphs using templates corresponding to different types of information. Mapping can involve establishing mapping relationships between different types of information and various files, and then performing mapping through these relationships.

[0106] In the above scheme, by fixing the structure of the algorithm project package and mapping each piece of information to a separate file, the project terminal can complete the access of the algorithm project based on the algorithm project package containing the file directory and resource package directory.

[0107] In some embodiments, the algorithm project access system can complete the data access of algorithm project packages through project data parsing, algorithm package uploading, generation of runtime node descriptions and storage models, and task registration. Furthermore, the algorithm project access system provides post-access runtime testing capabilities. By sending relevant data from failed tasks to a cloud virtual machine, the cloud virtual machine can easily simulate the environmental parameters of the project terminal and perform related debugging, thereby facilitating the verification of the algorithm project package after access. This reduces the access cost and improves the running efficiency of algorithm projects in different environments.

[0108] The algorithm project package can be generated in the algorithm project generation system. The algorithm project package can include project files, operator information files, scheduling files, and orchestration files. Additionally, the algorithm project package may include an environment configuration file. This environment configuration file can be generated according to the environment configuration of the project terminal. This environment configuration file indicates the storage path of each file in the algorithm project package on the project terminal, or it can be set in the terminal project. By reading this environment configuration file, the terminal project can store the parsed information according to its own environment configuration after parsing the algorithm project package. After editing in the algorithm project generation system, the algorithm project package can be exported, generating the files described above. The export process can also be a mapping process, meaning the directory structure of the algorithm project package is fixed, and the various types of information edited can be mapped to the files in the algorithm project package file directory, and the installation packages of operator models and computing engines can also be mapped to the corresponding files in the resource package directory. The structure of the algorithm project package can be referenced... Figure 2 The file directory primarily stores various information files within the project, such as project files, scheduling files, orchestration files, and operator information files. Project files mainly contain basic information like the project name and definition; scheduling files contain scheduling strategies and timer registration information; orchestration files contain relationships between nodes and node configuration information; and operator information files mainly include operator model definitions and configuration information. Type 1 and Type 2 resource packages primarily include installation packages for operator models and computing engines, and may also include installation packages for other resources. Algorithm project package files can be exported via the algorithm platform's export capability (visual page).

[0109] Understandably, after exporting the algorithm project from the generation system, to further verify the algorithm project package, it can be imported into a cloud virtual machine. The environment configuration of this cloud virtual machine is consistent with that of the project terminal. Online verification allows for real-time correction of parameters in the algorithm project package or parameters of the access system set in the cloud virtual machine. If the project can run in the cloud virtual machine, the access system can be packaged and set in the project terminal, and then the target file package can be imported into the project terminal through the access system. Alternatively, if the access system has been verified and set in the algorithm project in advance on the cloud virtual machine, it is not necessary to repeatedly import the access system into the algorithm terminal during subsequent project imports. Because the environment parameters in the cloud virtual machine are consistent with those in the project terminal, and both the cloud virtual machine and the project terminal use the aforementioned access system, the method for importing the algorithm project package into the cloud virtual machine can be the same as the method for importing it into the project terminal. The following describes how to import the algorithm project package into the cloud virtual machine as an example. If the algorithm project needs to be deployed to a project terminal in a different environment, the corresponding environment can also be configured on the cloud virtual machine first, and then the algorithm project can be debugged on that cloud virtual machine. If it runs normally, the algorithm project package can be imported into the corresponding project terminal.

[0110] After the algorithm project package is exported from the algorithm project generation system, it can be imported through the import function of the algorithm project access system, such as through the access system's API interface or visual page. After import, the access system will complete the data assembly based on the orchestration files, project files, scheduling files, resource files, etc. in the project package. The assembly process is as follows: First, the algorithm project package is decompressed to obtain resource files (the runtime JAR package of the computing engine and the installation package of the operator model, etc.), as well as project files, operator information files, scheduling files, and orchestration files.

[0111] Then, the operator model and computing engine are uploaded to the corresponding storage engine of the cloud virtual machine (project terminal).

[0112] The configuration parsing unit in the access system is used to parse the project file, operator information file, scheduling file, and orchestration file. Specifically, the JSON content of the project file is obtained, parsed, and then stored in the database. Storing in the database can be understood as filling the parsed data into the corresponding table in the cloud virtual machine (project terminal). The JSON content of the operator information file is obtained, parsed, and then stored in the database. Storing in the database can be understood as filling the parsed data into the corresponding table in the cloud virtual machine (project terminal). The JSON content of the orchestration file is obtained, parsed, and then stored in the database. Storing in the database can be understood as filling the parsed data into the corresponding data table or node association graph in the cloud virtual machine (project terminal). The tables into which the data is stored can be different for different files. The JSON content of the scheduling file is obtained, parsed, and then the scheduling task is registered.

[0113] In other words, during the assembly process, the resource files in the project are first uploaded to the storage medium of the target environment, and the files in the algorithm project package (project files, operator information files, orchestration description files (DAG graph files), scheduling information, etc.) are parsed. The parsing is mainly completed by the configuration parsing unit in the system, which performs different parsing processes for different file types.

[0114] The above embodiments described the fields contained in the orchestration file and the scheduling file. Here, we will continue to describe the project file and the operator information file.

[0115] The project file mainly includes the following fields: Code: Process code, used to describe the code of the orchestration DAG contained in the project; Version: Project version; Name: Project description; ProjectCode: Project code, used to identify the project; Description: Project description; ReleaseState: Project status; GlobalParams: Global parameter definitions; Tenantid: Tenant information, user information; TriggerType: Scheduling type (usually divided into single call or periodic call). In addition to the above information, special information can be extended for different scenarios.

[0116] The operator information file mainly includes the following fields: Name: Operator model name; Category: Category; Code: Operator model code; OSL: Operator model protocol; Version: Major version of the operator model; Subversion: Minor version of the operator model. Different major versions of the operator model may have different inputs and outputs, while minor versions of the operator model may have the same inputs and outputs but different internal implementations.

[0117] The ProcessCode and ProcessVersion in the node protocol and the association protocol between nodes in the orchestration file are the same as the Code and Version in the project file.

[0118] After parsing the algorithm project package, the imported package is processed. This includes uploading resource files to the execution storage medium, and configuring global parameters and initializing the DAG (including parameter configuration within nodes and DAG orchestration verification). As mentioned above, resource file uploads mainly include uploading the operator model installation package and runtime resource packages such as the computing engine. These can be stored in the storage engine, and during task execution, the cloud virtual machine (project terminal) can retrieve the relevant resource packages from the storage engine for processing. Specifically, the process for configuring parameters for each node and global parameters can be referenced as follows:

[0119] As mentioned above, the project files, operator information files, and orchestration files in the algorithm project package have been parsed and stored in the database. During parameter configuration, built-in parameter values, as well as parameter values ​​carried in the orchestration files and / or project files, can be loaded from the database. Parameter values ​​for each parameter are generated based on scripts, and parameter bucketing is calculated based on user input parameters. Parameter bucketing is explained as follows: parameter buckets are system-built-in keys, but they need to be directly input by the user or generated by a script. It can also be understood as supporting multiple sets of parameters for the same project, with each set of parameters being a bucket. The appropriate bucket can be selected based on the current environment during integration. For the same project, the parameter configuration priority can be as follows: user-input parameter values ​​> parameters generated by the parameter engine > built-in parameters from the configuration center > built-in parameters from files > built-in parameters from tables > dynamic built-in parameters > constant parameters. Here, built-in parameters from files can be parameters directly read from the orchestration files and / or project files, while built-in parameters from tables can be parameters read from the database after parsing and storing the orchestration files and / or project files. This reduces the possibility of errors in the database storage process leading to incorrect parameter value readings. The constants here can be the preset built-in parameter values ​​mentioned above. The built-in parameters of the configuration center (such as Spring Cloud Config, Consul, etcd, etc.) mainly depend on the specific configuration center implementation. Different configuration centers may have different built-in parameters and configuration items.

[0120] After the parameter configuration is completed, the import, initialization and parameter configuration of the algorithm project can be considered complete. Based on the above steps, the project can be run. The running nodes required for the run are calculated through the node information and node association information in the project, and the corresponding running instances are generated. The system will submit the running instances to the corresponding task executor. The executor pulls the corresponding resource files from the resource storage medium to the task executor to complete the node execution.

[0121] If the project can run normally in a cloud virtual machine, the algorithm project's access system can be packaged. For example, different environment parameters can be selected to complete the packaging process for different deployment environments. For instance, the first or second packaging method can be selected based on the project's terminal type. The first packaging method may include the following process: obtaining the local resource storage path, the access system's runtime package, and the storage path, and packaging them to obtain the access system's installation package. The second packaging method may include the following process: connecting to the resource storage cluster, connecting to the task executor, connecting to the scheduler, and starting the application.

[0122] In edge-to-device and cloud-edge hybrid scenarios, the access system connects to the edge via a cloud virtual machine and network integration, along with APIs. This means the access system is deployed in a cloud virtual machine environment that is identical to the final delivery environment. Therefore, the project package can undergo process verification within the virtual machine environment. After verification, it connects to the edge via TCP / IP and distributes the algorithm project package to the edge server via the edge API. For details, please refer to [link to relevant documentation]. Figure 8 Communication between cloud virtual machines and edge servers and edge processors can include:

[0123] Step S61: Deploy the project on a virtual machine in the cloud.

[0124] Step S62: Perform project initialization.

[0125] Step S63: Execute the virtual machine task.

[0126] Step S64: Verify the virtual machine results.

[0127] If the algorithm project runs successfully on a cloud virtual machine, step S64 can be executed.

[0128] Step S65: Deploy the project on the edge server using TCP / IP protocol + API.

[0129] Step S66: Initialize the project edge and resource package.

[0130] Step S67: Submit the task to the edge processor.

[0131] Step S68: The edge processor runs the task.

[0132] Step S69: Return the task status to the edge server.

[0133] In some embodiments, the operator model can be updated. Specifically, the access system provides an API + message body approach to accomplish this. The API interface directly updates the corresponding operator model in the device using the operator code, version, and operator model installation package, while specifying the corresponding project to be updated by selecting the project ID. The message body approach utilizes a message transmission mechanism provided by the device to interface with the user's algorithm platform. The message body content can include the following fields: OperatorCode: operator code, Version: operator version to be updated, OrigVersion: previous operator version, OperatorPath: path to retrieve the latest operator, ProjectCode: identifier of the updated project, OSL: operator standardization description, InstanceCode: update instance code. After receiving the message body content, the system retrieves the corresponding operator package using the operator code, operator version, and operator path, uploads it to the corresponding storage medium, and performs verification.

[0134] Specifically, updating the operator model via API interface can include the following steps: importing the operator code, version, and operator model installation package through the API interface; updating the relevant information of the operator model in the access system; submitting the new operator model installation package to the runner (also known as the processor) of the project terminal; updating the relevant project in the runner; submitting the operator installation package to the storage medium; the storage medium returning the latest operator model address to the runner; and the runner executing the task. After receiving the operator package submitted by the access system, the runner can also return a response to the access system, which in turn returns a response to the user. The access system updates the relevant information of the operator model in the following way: since the parsed data from the operator information file is stored in the database during project access, updating the relevant information can be considered as updating the stored content.

[0135] The process of updating the operator model via message can be as follows: A message body is sent to the access system, which updates the relevant information of the operator model. Then, the access system retrieves the operator model installation package according to the address in the message body, submits the obtained operator model installation package to the runner, receives the response from the runner, and then returns the response to the user (who can be the user platform). The runner updates the relevant items and submits the operator installation package to the storage medium. The storage medium returns the latest operator model address to the runner, and the runner executes the task.

[0136] In the process of executing various tasks within the project, task execution failures are inevitable on the project terminal. Specifically, during actual online operation, errors such as operator model node errors often occur. The access system provides a task management unit. When a task starts, the task management unit monitors the logs of the currently running task. In the battery field, algorithm execution typically requires segmented execution. Therefore, in addition to monitoring task status and task logs, the task management unit also extracts the segmented data for each run and stores the segmented data, error logs, operator packages, and environment parameters in the corresponding environment's storage medium. When deployed in different environments, a virtual environment identical to the project terminal can be built in a cloud virtual machine. After pulling the corresponding error dataset, error logs, and algorithm packages from the access system, data debugging can be performed in the virtual environment. After successful debugging, the corresponding operator model and other parameters can be modified and upgraded through the device's update interface.

[0137] Optionally, the working relationship between timers, task management units, task executors, and log storage media in the project terminal can be referenced. Figure 9 As shown:

[0138] Step S71: Determine the time to execute the task.

[0139] Step S72: Arrange the node information of the task.

[0140] Step S73: Submit the task to the task executor.

[0141] Step S74: Return a response to the task management unit.

[0142] Step S75: Task execution.

[0143] Step S76: Submit the error log, dataset, error operator package, and environment parameters to the log storage medium.

[0144] Step S77: Return the log storage address to the task management unit.

[0145] Step S78: Send a retrieval command to the log storage medium.

[0146] For example, when the log management unit receives a log retrieval instruction, it executes step S78.

[0147] Step S79: In response to the fetch command, return an error resource.

[0148] Step S80: Return the error resource to the preset receiver.

[0149] Step S81: Receive the modified code.

[0150] Step S82: Submit a single-run task to the task executor.

[0151] Step S83: Single run.

[0152] Step S84: Return the result.

[0153] Step S85: Return the result.

[0154] Step S86: Send debugging data to the access system.

[0155] For example, if a problem is determined in the operator model, a message body is sent to the access system so that the access system can update the operator model after receiving the message body.

[0156] Please see Figure 10 , Figure 10 This is a schematic diagram of an embodiment of the algorithm project access system of this application. The algorithm project access system 40 can be installed on the project terminal. The algorithm project access system 40 includes: an algorithm project receiving module 41, used to obtain an algorithm project package, which includes a file directory and a resource package directory. The file directory includes several files required for the execution of each algorithm project, and the several files carry information of different types of algorithm projects. The resource package directory includes an installation package containing several operator models required for the execution of the algorithm project; a parsing module 42, used to parse each file in the algorithm project package, and store the parsed information of various types into the storage medium corresponding to the information of various types in the project terminal, and store the installation packages of each operator model into the storage engine and generate the storage model of each operator model; and a running module 43, used to generate tasks of the algorithm project based on at least some types of information stored in each storage medium and call the corresponding storage model to execute the tasks.

[0157] In the above scheme, an algorithm project package with file directories and resource package directories is constructed. Each directory contains information about different types of algorithm projects. After parsing the algorithm project package, the information of each type can be stored in its corresponding storage medium, and the algorithm model can be stored in the corresponding storage engine. Then, based on the parsed information of various types of algorithm projects, the corresponding tasks are determined and executed. In addition to importing the algorithm project into the project terminal, because the information in each file of the algorithm project package is independent, if there is a need to update the algorithm project, the information or operator model in the project terminal that needs to be updated can be updated specifically, without updating the entire algorithm project package and re-importing it into the project terminal.

[0158] In some embodiments, several files include a node arrangement file, which includes node arrangement information of each node in the algorithm project. The parsing module 42 parses each file in the algorithm project package and stores the parsed information of various classes into the storage medium corresponding to the information of each class in the project terminal. This includes: parsing the node arrangement file to obtain the association relationship between each node and the definition information of each node; writing the association relationship between each node and the definition information of each node into a node association graph, wherein at least some nodes in the node association graph are operator model nodes.

[0159] In the above scheme, a separate node orchestration file is set up in the algorithm project package, and the algorithm project orchestration information is stored separately in the node association graph based on the association relationship between nodes obtained by parsing the node orchestration file and the definition information of each node.

[0160] In some embodiments, the definition information of each node includes the node type of each node and the indication information of each node. The node type includes any one of the following: data source node, operator model node, database node, and computing engine node.

[0161] In the above scheme, by defining the types of nodes and the indication information of each node, it is convenient to determine the execution flow of the task according to the type of each node. Also, since the data source node in the algorithm project may call multiple data sources, the operator model node may call multiple operator models, and similarly, the database node and the computing engine node may call multiple databases and computing engines, the specific data source, operator model, database or computing engine that each node needs to use can be determined according to the indication information of each node.

[0162] In some embodiments, the running module 43 generates tasks for the algorithm project based on at least some types of information stored in each storage medium and calls the corresponding storage model to execute the tasks, including: taking the data source node as the starting node, and determining the branch in the node association graph based on the definition information of each node in the node association graph and the association relationship between each node, and taking the branch as the task; obtaining the storage model that needs to be called in the task from the storage engine to execute the task.

[0163] In the above scheme, after the node association graph is determined, each data source node can have multiple subsequent nodes. The data source node can be taken as the first node. Based on the connection relationship between the nodes, multiple tasks with the data source node as the first node can be determined. The storage engine corresponding to the operator model node contained in each task needs to be called to execute the task.

[0164] In some embodiments, the plurality of files include a project file, which carries parameter values ​​of global parameters in the algorithm project. The orchestration information includes parameter values ​​of parameters in at least some nodes. The algorithm project access system 40 also includes a parameter configuration module (not shown in the figure). The parameter configuration module is used to: determine a reference parameter value group for each parameter based on the parameter values ​​of several parameters in the orchestration file and / or project file. The reference parameter value group for each parameter includes at least one of the following: parameter values ​​of parameters carried in the orchestration file and / or project file, parameter values ​​about parameters generated by the project terminal, preset built-in parameter values ​​about parameters, and parameter values ​​about parameters input by the user; and configure parameters for parameters in at least some nodes and / or global parameters in the node association graph using the reference parameter value groups for each parameter.

[0165] In the above scheme, after parsing the algorithm project package to obtain the parameters of each node required by the algorithm project and / or the global parameters, the reference parameter value group of each parameter is determined by combining the parameter values ​​generated by the project terminal, the built-in parameter values ​​of the parameters, and / or the parameter values ​​input by the user. This makes it easier to select parameter values ​​from the reference parameter value group for configuration. Compared with configuring parameters using only a single parameter value, the parameter configuration method provided by this scheme is more flexible and can reduce the occurrence of project running errors due to incorrect configuration of a single parameter value.

[0166] In some embodiments, the parameter configuration module uses the reference parameter value group of each parameter to configure the parameters in at least some nodes in the node association graph and / or the global parameters, including: performing the following steps for each parameter: determining the priority among the reference parameter values ​​in the reference parameter value group of the parameter; taking the reference parameter value in the reference parameter value group that meets the preset priority condition as the target parameter value; and configuring each parameter using each target parameter value.

[0167] In the above scheme, by setting priorities for the reference parameter values ​​of each parameter, the parameter values ​​can be determined according to each priority, thereby making the determined parameter values ​​more accurate.

[0168] In some embodiments, the parameter configuration module determines the priority among the reference parameter values ​​in the reference parameter value group, including: determining the category to which the parameter belongs; determining the priority sorting method corresponding to the category to which the parameter belongs from several priority sorting methods; and determining the priority among the reference parameter values ​​in the reference parameter value group according to the priority sorting method corresponding to the category to which the parameter belongs.

[0169] In the above scheme, different categories of parameters can be set with different priority sorting methods, so that the priority sorting methods set for different categories of parameters are the same or different. Compared with setting the same priority sorting method for different types of parameters, this scheme can make the parameter values ​​determined by each parameter more accurate.

[0170] In some embodiments, several files include a scheduling file, which includes the offset type and offset of the start running time of the algorithm project, and the offset type and offset of the stop running time. The running module 43 is further configured to: determine the start running time of the algorithm project based on the offset type and offset of the start running time, and determine the stop running time of the algorithm project based on the offset type and offset of the stop running time; and register the task for scheduled execution based on the start running time and stop running time of the algorithm project.

[0171] In the above solution, some scenarios may require running the algorithm project within a specific time interval. Therefore, the offset type and offset amount of the start and end running times can be set to achieve scheduled running of the algorithm project.

[0172] In some embodiments, the files further include an operator information file, which includes the identifier and version number of each operator model. The identifier and version number of each operator model parsed from the operator information file are written into the operator information table of the project terminal. The running module 43 is further configured to: receive an update message, which includes the new version number of the operator model to be updated and the acquisition path of the new version installation package; acquire the installation package of the new version of the operator model to be updated based on the acquisition path of the new version of the operator model to be updated; and, in response to the new version number of the operator model to be updated being higher than the version number of the operator model to be updated in the operator information table, update the operator model to be updated using the installation package of the new version of the operator model to be updated and update the version number of the operator model to be updated in the operator information table.

[0173] In the above scheme, the current update of algorithm projects is still at the stage of generating a new algorithm project package and replacing the old algorithm project package with the new algorithm project package. This scheme sends an update message to the project terminal and includes the acquisition path of the new version installation package of the operator model to be updated in the update message. This allows the project terminal to obtain the new version installation package according to the acquisition path and update the operator model to be updated.

[0174] In some embodiments, the files also include an operator information file, which includes the identifier and version number of each operator model. The identifier and version number of each operator model parsed from the operator information file are written into the operator information table of the project terminal. The running module 43 is further configured to: receive the identifier, version number, and installation package of a new operator model imported from the API interface of the project terminal; compare the identifier of the new operator model with the identifiers of existing operator models in the operator information table to determine the old operator model corresponding to the new operator model; and, in response to the fact that the version number of the new operator model is higher than the version number of the old operator model in the operator information table, update the old operator model using the installation package of the new operator model and update the version number of the old operator model in the operator information table.

[0175] In the above scheme, the operator model can also be updated by receiving the identifier of the imported new operator model and the installation package through the API interface, making the operator model update method more diversified.

[0176] In some embodiments, the algorithm project includes several tasks, which are run in segments. The running module 43 is also used to: obtain log data, running data and running environment parameters of each task generated during the execution of each task in the algorithm project; and store the obtained log data, running data and running environment parameters of each task in the corresponding storage medium in the project terminal.

[0177] In the above scheme, by collecting log data, running data and running environment parameters generated during the execution of each task in the algorithm project, it is convenient to trace the execution process of the algorithm project in the future.

[0178] In some embodiments, the running module 43 is further configured to: in response to a failed task in the algorithm project, send relevant data of the failed task to a preset receiver, the relevant data including log data, running data, running environment parameters, and installation package of the operator model used in the failed task; receive debugging data sent by the preset receiver, the debugging data including update parameters of the operator model, update parameters of the running environment parameters, and / or update parameters of the access system of the algorithm project; and adjust the operator model, running environment parameters, and / or access system of the algorithm project corresponding to the failed task based on the received debugging data.

[0179] In the above scheme, by sending the relevant data of the failed task to a preset recipient, and having the preset recipient re-simulate the task execution process based on the relevant data, the cause of the task failure can be determined, and targeted debugging data can be proposed, so that the project terminal can make corresponding adjustments after receiving the debugging data.

[0180] In some embodiments, the running module 43 is further configured to: display relevant information about the algorithm project on the display interface of the project terminal, the relevant information about the algorithm project including the access status and / or running status of the algorithm project.

[0181] In the above solution, displaying relevant information about the algorithm project on the project execution display interface allows users to easily understand the access status and / or operation status of the algorithm project in a timely manner.

[0182] Please see Figure 11 The algorithm project generation system 50 provided in this application is applied to an algorithm project generation device. The algorithm project generation system includes: a data receiving module 51 and an algorithm project package generation module 52. The data receiving module 51 is used to acquire different types of information required to execute the algorithm project and installation packages of several operator models. The algorithm project package generation module 52 is used to generate an algorithm project package based on the different types of information and the installation packages of several operator models. The algorithm project package includes a file directory and a resource package directory. The file directory includes several files required to execute the algorithm project, and the several files carry different types of information about the algorithm project. The resource package directory includes installation packages of several operator models required to execute the algorithm project. The algorithm project package can be imported into the project terminal after being acquired by the project terminal based on the algorithm project access system 40.

[0183] In the above scheme, an algorithm project package with file directories and resource package directories is constructed. Each directory contains information about different types of algorithm projects. After parsing the algorithm project package, the information of each type can be stored in its corresponding storage medium, and the algorithm model can be stored in the corresponding storage engine. Then, based on the parsed information of various types of algorithm projects, the corresponding tasks are determined and executed. In addition to importing the algorithm project into the project terminal, because the information in each file of the algorithm project package is independent, if the algorithm project needs to be updated, the information or operator model in the project terminal that needs to be updated can be updated specifically, without updating the entire algorithm project package and re-importing it into the project terminal.

[0184] In some embodiments, the algorithm project package generation module 52 generates an algorithm project package based on different types of information and installation packages of several operator models, including: mapping the obtained information of various types to files in the file directory of the algorithm project package, and mapping the installation packages of each operator model to the resource package directory.

[0185] In the above scheme, by fixing the structure of the algorithm project package and mapping each piece of information to a separate file, the project terminal can complete the access of the algorithm project based on the algorithm project package containing the file directory and resource package directory.

[0186] Please see Figure 12 , Figure 12 This is a schematic diagram of the structure of an embodiment of the electronic device of this application. The electronic device 60 includes a memory 61 and a processor 62. The processor 62 is used to execute program instructions stored in the memory 61 to implement the steps in the access method embodiment of any of the above-described algorithm items or the steps in the generation method embodiment of the above-described algorithm items. In a specific implementation scenario, the electronic device 60 may include, but is not limited to, a microcomputer or a server. In addition, the electronic device 60 may also include a laptop computer, a tablet computer, or other carrier device, which is not limited here.

[0187] Specifically, processor 62 controls itself and memory 61 to implement the steps in the access method embodiment of any of the above-described algorithm projects or the steps in the generation method embodiment of the above-described algorithm projects. Processor 62 can also be referred to as a CPU (Central Processing Unit). Processor 62 may be an integrated circuit chip with signal processing capabilities. Processor 62 can also be a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. A general-purpose processor can be a microprocessor or any conventional processor. Furthermore, processor 62 can be implemented using integrated circuit chips.

[0188] Please see Figure 13 , Figure 13 This is a schematic diagram of a computer-readable storage medium according to an embodiment of the present application. The computer-readable storage medium 70 stores program instructions 701 thereon. When the program instructions 701 are executed by a processor, they implement the steps in the access method embodiment of any of the above-described algorithm items or the steps in the generation method embodiment of the above-described algorithm items.

[0189] In the above scheme, an algorithm project package with file directories and resource package directories is constructed. Each directory contains information about different types of algorithm projects. After parsing the algorithm project package, the information of each type can be stored in its corresponding storage medium, and the algorithm model can be stored in the corresponding storage engine. Then, based on the parsed information of various types of algorithm projects, the corresponding tasks are determined and executed. In addition to importing the algorithm project into the project terminal, because the information in each file of the algorithm project package is independent, if there is a need to update the algorithm project, the information or operator model in the project terminal that needs to be updated can be updated specifically, without updating the entire algorithm project package and re-importing it into the project terminal.

[0190] In some embodiments, the functions or modules of the apparatus provided in this disclosure can be used to perform the methods described in the above method embodiments. The specific implementation can be referred to the description of the above method embodiments, and for the sake of brevity, it will not be repeated here.

[0191] The description of the various embodiments above tends to emphasize the differences between the various embodiments. The similarities or similarities between them can be referred to, and for the sake of brevity, they will not be repeated here.

[0192] In the several embodiments provided in this application, it should be understood that the disclosed methods and apparatus can be implemented in other ways. For example, the apparatus implementations described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, units or components may be combined or integrated into another system, or some features may be ignored or not executed. In another image location, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection of devices or units may be electrical, mechanical, or other forms.

[0193] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) or processor to execute all or part of the steps of the methods in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

Claims

1. A method for accessing an algorithm project, applied to a project terminal, characterized in that, The access methods for the algorithm project include: Obtain the algorithm project package, which includes a file directory and a resource package directory. The file directory includes several files required for the execution of each algorithm project, and these files carry different types of information about the algorithm project. The resource package directory includes installation packages for several operator models required for the execution of the algorithm project. Each file in the algorithm project package is parsed, and the parsed information of each class is stored in the storage medium corresponding to the information of each class in the project terminal. The installation package of each operator model is stored in the storage engine and the storage model of each operator model is generated. Based on at least some types of information stored in each of the aforementioned storage media, a task for the algorithm project is generated and the corresponding storage model is invoked to execute the task.

2. The method according to claim 1, characterized in that, The plurality of files includes a node orchestration file, which contains node orchestration information for each node in the algorithm project. The process of parsing each file in the algorithm project package and storing the parsed information of various classes into the corresponding storage medium in the project terminal includes: The node arrangement file is parsed to obtain the relationships between the nodes and the definition information of each node. The relationships between the nodes and the definition information of each node are written into the node association graph, wherein at least some of the nodes in the node association graph are operator model nodes.

3. The method according to claim 2, characterized in that, The definition information of each node includes the node type of each node and the indication information of each node. The node type includes any one of the following: data source node, operator model node, database node, and computing engine node.

4. The method according to claim 3, characterized in that, The step of generating tasks for the algorithm project based on at least some types of information stored in each of the storage media and calling the corresponding storage model to execute the tasks includes: Taking the data source node as the starting node, and based on the definition information of each node in the node association graph and the association relationship between each node, determine the branch where the data source node is located in the node association graph and take the branch as the task; The storage model required for the task is obtained from the storage engine to execute the task.

5. The method according to any one of claims 2-4, characterized in that, The plurality of files includes a project file, which carries parameter values ​​of global parameters in the algorithm project. The orchestration information includes parameter values ​​of parameters in at least some nodes. The method further includes: Based on the parameter values ​​of several parameters in the arrangement file and / or the project file, a reference parameter value group is determined for each parameter. The reference parameter values ​​in each parameter reference value group include at least one of the following: the parameter value of the parameter carried in the arrangement file and / or the project file, the parameter value of the parameter generated by the project terminal, the preset built-in parameter value of the parameter, and the parameter value of the parameter input by the user. Using the reference parameter value groups of each parameter, the parameters in at least some nodes and / or the global parameters in the node association graph are configured respectively.

6. The method for accessing algorithm projects according to claim 5, characterized in that, The step of configuring parameters for at least some nodes and / or global parameters in the node association graph using reference parameter value groups for each of the aforementioned parameters includes: Perform the following steps for each of the parameters: Determine the priority among the reference parameter values ​​in the reference parameter value group of the parameter; The reference parameter values ​​in the reference parameter value group that meet the preset priority conditions are taken as the target parameter values; Each of the aforementioned parameters is configured using its respective target parameter value.

7. The method for accessing algorithm projects according to claim 6, characterized in that, The determination of the priority among the reference parameter values ​​in the reference parameter value group for the parameter includes: Determine the category to which the parameter belongs; From several priority sorting methods, determine the priority sorting method corresponding to the category to which the parameter belongs; The priority among the reference parameter values ​​in the reference parameter value group is determined according to the priority sorting method corresponding to the category to which the parameter belongs.

8. The method according to any one of claims 1 to 7, characterized in that, The plurality of files includes a scheduling file, which includes the offset type and offset of the start running time and the offset type and offset of the stop running time of the algorithm project. The method further includes: Based on the offset type and offset amount of the start running time, the start running time of the algorithm project is determined, and based on the offset type and offset amount of the stop running time, the stop running time of the algorithm project is determined. Based on the start time and stop time of the algorithm project, the task is registered so that it can be executed at regular intervals.

9. The method according to any one of claims 1 to 8, characterized in that, The files also include an operator information file, which includes the identifier and version number of each operator model. The identifier and version number of each operator model parsed from the operator information file are written into the operator information table of the project terminal. The method further includes: Receive an update message, which includes the new version number of the operator model to be updated and the path to obtain the new version installation package; Based on the acquisition path of the new version of the operator model to be updated, obtain the installation package of the new version of the operator model to be updated; In response to the fact that the new version number of the operator model to be updated is higher than the version number of the operator model to be updated in the operator information table, the operator model to be updated is updated using the installation package of the new version of the operator model to be updated, and the version number of the operator model to be updated in the operator information table is updated.

10. The method for accessing an algorithm project according to any one of claims 1 to 8, characterized in that, The files also include an operator information file, which includes the identifier and version number of each operator model. The identifier and version number of each operator model parsed from the operator information file are written into the operator information table of the project terminal. The method further includes: Receive the identifier, version number, and installation package of the new operator model imported from the API interface of the project terminal; The identifier of the new operator model is compared with the identifiers of the existing operator models in the operator information table to determine the old operator model corresponding to the new operator model; In response to the fact that the version number of the new operator model is higher than the version number of the old operator model in the operator information table, the old operator model is updated using the installation package of the new operator model, and the version number of the old operator model in the operator information table is updated.

11. The method for accessing an algorithm project according to any one of claims 1 to 10, characterized in that, The algorithm project includes several tasks, which are run in segments. The access method for the algorithm project also includes: Obtain the log data, runtime data, and runtime environment parameters of each task generated during the execution of each task in the algorithm project; The obtained log data, running data, and running environment parameters of each task are stored in the corresponding storage medium in the project terminal.

12. The method for accessing algorithm projects according to claim 11, characterized in that, The project terminal includes an algorithm project access system, and the algorithm project access method is executed by the algorithm project access system. The algorithm project access method further includes: In response to the existence of a failed task in the algorithm project, the relevant data of the failed task is sent to a preset receiver. The relevant data includes the log data, running data, running environment parameters and the installation package of the operator model used in the failed task. Receive debugging data sent by the preset receiver, the debugging data including update parameters of the operator model, update parameters of the operating environment parameters and / or update parameters of the access system of the algorithm project; Based on the received debugging data, adjust the operator model, runtime environment parameters, and / or the access system of the algorithm project corresponding to the failed task.

13. The method for accessing an algorithm project according to any one of claims 1 to 12, characterized in that, The access method for the algorithm project also includes: The relevant information of the algorithm project is displayed on the display interface of the project terminal. The relevant information of the algorithm project includes the access status and / or operation status of the algorithm project.

14. A method for generating algorithm projects, applied to an algorithm project generation device, characterized in that, The method for generating the algorithm project includes: Obtain the different types of information required for executing the algorithm project, as well as the installation packages for several operator models; Based on the different types of information and the installation packages of the several operator models, an algorithm project package is generated for the algorithm project. The algorithm project package includes a file directory and a resource package directory. The file directory includes several files required for the execution of the algorithm project. The several files carry different types of information about the algorithm project. The resource package directory includes the installation packages of the several operator models required for the execution of the algorithm project. The algorithm project package can be imported into the project terminal after being obtained by the project terminal, based on the access method of any one of the algorithm projects in claims 1 to 13.

15. The method for generating algorithm projects according to claim 14, characterized in that, The algorithm project package generated based on the different types of information and the installation packages of the several operator models includes: The information of each class is mapped to the respective files in the file directory of the algorithm project package, and the installation packages of each operator model are mapped to the resource package directory.

16. An access system for an algorithm project, applied to a project terminal, characterized in that, The access system for the algorithm project includes: An algorithm project receiving module is used to obtain an algorithm project package. The algorithm project package includes a file directory and a resource package directory. The file directory includes several files required for the execution of each algorithm project. The several files carry different types of information about the algorithm project. The resource package directory includes installation packages for several operator models required for the execution of the algorithm project. The parsing module is used to parse each file in the algorithm project package, store the parsed information of various classes into the storage medium corresponding to the information of various classes in the project terminal, and store the installation package of each operator model into the storage engine and generate the storage model of each operator model. The execution module is used to generate tasks for the algorithm project based on at least some types of information stored in each of the storage media and to call the corresponding storage model to execute the tasks.

17. An algorithm project generation system, applied to an algorithm project generation device, characterized in that, The algorithm project generation system includes: The data receiving module is used to acquire different types of information required for the execution algorithm project, as well as the installation packages of several operator models; An algorithm project package generation module is used to generate an algorithm project package for the algorithm project based on the different types of information and the installation packages of the several operator models. The algorithm project package includes a file directory and a resource package directory. The file directory includes several files required for the execution of the algorithm project. The several files carry different types of information about the algorithm project. The resource package directory includes the installation packages of the several operator models required for the execution of the algorithm project. The algorithm project package can be imported into the project terminal after being obtained by the project terminal, based on the algorithm project access system described in claim 16.

18. An electronic device, characterized in that, It includes a memory and a processor, the processor being configured to execute program instructions stored in the memory to implement the algorithm project access method according to any one of claims 1 to 13, or to implement the algorithm project generation method according to any one of claims 14 to 15.

19. A computer-readable storage medium having program instructions stored thereon, characterized in that, When the program instructions are executed by the processor, they implement the algorithm project access method according to any one of claims 1 to 13, or the algorithm project generation method according to any one of claims 14 to 15.

Images