Data processing method, system and electronic device

Abstract

The application discloses a data processing method, system and electronic equipment. The method comprises the following steps: acquiring a calculation flow for describing an original model, wherein the calculation flow needs to use a calculation resource to complete when the original model is run; identifying at least one calculation sub-flow from the calculation flow; performing simplification processing on different calculation sub-flows, wherein the calculation resource amount required by the simplified calculation sub-flow is less than the calculation resource amount required by the calculation sub-flow before simplification; mapping the simplified calculation sub-flow to a corresponding calculation unit to obtain a calculation unit set; performing fusion processing on the calculation units contained in the calculation unit set, and generating a target model corresponding to the original model based on the fusion result, wherein different calculation sub-flows of the target model need to use matched calculation resources for processing. The application solves the technical problem of low data processing efficiency.

Description

Technical Field

[0001] This application relates to the field of computers, and more specifically, to a data processing method, system, and electronic device. Background Technology

[0002] Currently, machine learning compilers can automatically adjust models; however, they do not address the problems caused by a large number of computational processes in the model. For example, redundant computations are inevitably introduced during the execution of a large number of computational processes, leading to reduced model performance and low data processing efficiency.

[0003] There is currently no effective solution to the above problems. Summary of the Invention

[0004] This application provides a data processing method, system, and electronic device to at least solve the technical problem of low data processing efficiency.

[0005] According to one aspect of the embodiments of this application, a data processing method is provided. The method may include: obtaining a computational flow describing an original model, wherein running the original model requires computational resources to complete the computational flow; identifying at least one computational sub-flow from the computational flow; simplifying different computational sub-flows, wherein the simplified computational sub-flow requires less computational resources than the original computational sub-flow; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target model corresponding to the original model based on the fusion result, wherein different computational sub-flows of the target model require matching computational resources for processing.

[0006] According to another aspect of the embodiments of this application, another data processing method is provided. The method may include: obtaining a computational flow describing an original model by calling a first interface, wherein the first interface includes a first parameter, the value of which is the computational flow, and computational resources are required to complete the computational flow when running the original model; identifying at least one computational sub-flow from the computational flow; simplifying different computational sub-flows, wherein the simplified computational sub-flow requires less computational resources than the unsimplified computational sub-flow; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target model corresponding to the original model based on the fusion result, wherein different computational sub-flows of the target model require matching computational resources for processing; and outputting the target model by calling a second interface, wherein the second interface includes a second parameter, the value of which is the target model.

[0007] According to another aspect of the embodiments of this application, an information recommendation method is provided. The method may include: obtaining a computational flow describing an original recommendation model, wherein the original recommendation model is used to determine service information to be recommended to a target object, and running the original recommendation model requires computational resources to complete the computational flow; simplifying different computational sub-flows, wherein the simplified computational sub-flows require less computational resources than the unsimplified computational sub-flows; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target recommendation model corresponding to the original recommendation model based on the fusion result, wherein different computational sub-flows of the target recommendation model require matching computational resources for processing to generate service information.

[0008] According to another aspect of the embodiments of this application, a data processing system is provided. The system may include: a client, configured to detect model processing requests on an interactive interface, wherein the model processing request requests a cloud server to process an original model; a cloud server, configured to respond to the model processing request by obtaining a computational flow describing the original model, wherein running the original model requires computing resources to complete the computational flow; identifying at least one computational sub-flow from the computational flow; simplifying different computational sub-flows, wherein the simplified computational sub-flows require less computing resources than the unsimplified computational sub-flows; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units and generating a target model corresponding to the original model based on the fusion result; and a computing terminal, configured to call computing resources matching different computational sub-flows of the target model, process the corresponding computational sub-flows, and obtain computational results.

[0009] According to another aspect of the embodiments of this application, an electronic device is also provided, which may include a memory and a processor: the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions, wherein when the computer-executable instructions are executed by the processor, the data processing method of any one of the above is implemented.

[0010] According to another aspect of the embodiments of this application, a processor is also provided, which is used to run a program, wherein the data processing method of any one of the above is executed when the program is running.

[0011] According to another aspect of the embodiments of this application, a computer-readable storage medium is also provided, the computer-readable storage medium including a stored program, wherein, when the program is running, it controls the device where the storage medium is located to execute the data processing method described above.

[0012] In this embodiment, the original model can be identified to determine the computational flow that requires computing resources to run it. Computational sub-flows can be identified from this flow, and simplified based on the amount of computing resources required, resulting in simplified sub-flows with fewer resources. These sub-flows can be mapped to corresponding computing units for fusion processing, generating a fusion result. The target model corresponding to the original model can be generated based on the fusion result, thus updating the original model. Since the original model contains numerous computational flows, many problems arise. By calculating the computational sub-flows and their required computing resources, the performance degradation caused by redundant computations introduced by numerous computational flows can be avoided, thereby improving data processing efficiency and solving the problem of low data processing efficiency.

[0013] It is worth noting that the general description above and the detailed description that follow are merely for illustrative purposes and do not constitute a limitation on this application. Attached Figure Description

[0014] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments of this application and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0015] Figure 1 This is a schematic diagram illustrating an application scenario of a data processing method according to an embodiment of this application;

[0016] Figure 2 This is a structural block diagram of a computing environment for a data processing method according to an embodiment of this application;

[0017] Figure 3 This is a flowchart of a data processing method according to an embodiment of this application;

[0018] Figure 4 This is a flowchart of another data processing method according to an embodiment of this application;

[0019] Figure 5 This is a flowchart of an information recommendation method according to an embodiment of this application;

[0020] Figure 6 This is a schematic diagram of a data processing system according to an embodiment of this application;

[0021] Figure 7 This is a flowchart illustrating the compilation and adjustment of a large number of embedded columns in a deep recommendation model according to an embodiment of this application;

[0022] Figure 8 This is a flowchart illustrating the identification of embedded columns according to an embodiment of this application;

[0023] Figure 9 This is a flowchart illustrating the joint operation of a CPU and a GPU according to an embodiment of this application;

[0024] Figure 10 This is a schematic diagram of a data processing apparatus according to an embodiment of this application;

[0025] Figure 11 This is a schematic diagram of another data processing apparatus according to an embodiment of this application;

[0026] Figure 12 This is a schematic diagram of an information recommendation device according to an embodiment of this application;

[0027] Figure 13 This is a structural block diagram of a computer terminal according to an embodiment of this application;

[0028] Figure 14 This is a block diagram of an electronic device according to an embodiment of the present application of a data processing method;

[0029] Figure 15 This is a hardware structure block diagram of a computer terminal (or mobile device) for implementing a data processing method according to an embodiment of this application; Detailed Implementation

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

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

[0032] First, some nouns or terms that appear in the description of the embodiments of this application shall be interpreted as follows:

[0033] An embedding column is a computational subgraph that transforms an input feature into an embedding vector by processing and querying an embedding table.

[0034] Deep recommendation models refer to models built using deep learning technology for recommendation systems. The purpose of recommendation systems is to recommend relevant products or services to users based on their historical behavior and preferences.

[0035] A machine learning compiler can automatically transform a machine learning model into an efficient computational graph, code, or instructions based on its characteristics, thereby accelerating the training or derivation process of the model.

[0036] Computation graphs can be used to describe the computational process of machine learning models. Each node represents a computational operation, and the edges between nodes represent data flow and dependencies.

[0037] Dynamic shape refers to the shape of each tensor in the model computation graph, which can only be obtained at runtime and is uncertain during compilation.

[0038] Example 1

[0039] According to an embodiment of this application, a data processing method is provided. It should be noted that the steps shown in the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions. Furthermore, although a logical order is shown in the flowchart, in some cases, the steps shown or described may be executed in a different order than that shown here.

[0040] According to one aspect of the embodiments of this application, a data processing method is provided. As an optional implementation, the above-described data processing method may be applied, but is not limited to, to applications such as... Figure 1The application scenarios shown. Figure 1 This is a schematic diagram illustrating an application scenario of a data processing method according to an embodiment of this application, such as... Figure 1 As shown, in the application scenario, terminal device 102 can communicate with server 106 via network 104, but is not limited to this. Server 106 can perform operations on database 108, such as write or read data operations. Terminal device 102 may include, but is not limited to, a human-computer interaction screen, a processor, and a memory. The human-computer interaction screen may be used to display software or applications requiring recommended service information, historical behavior information, and recommended information on terminal device 102. The processor may be used to respond to the human-computer interaction operations, execute corresponding operations, or generate corresponding instructions and send the generated instructions to server 106. For example, when a target object opens software or applications requiring recommended service information on terminal device 102, the processor can detect the target object's operations on the software or application, generate historical behavior information of the target object, and send the historical behavior information to server 106, where server 106 can be a cloud server. The memory is used to store relevant data, such as software or applications requiring recommended service information, historical behavior information of the target object, and service information finally obtained from server 106. After receiving the historical behavior information, the server 106 can store the historical behavior information in the database 108, where the database 108 can be a database in the cloud server.

[0041] As an optional approach, the following steps in the data processing method can be executed on server 106: Step S102, obtaining a computational flow describing the original model, wherein computational resources are required to complete the computational flow when running the original model; Step S104, identifying at least one computational sub-flow from the computational flow; Step S106, simplifying different computational sub-flows, wherein the amount of computational resources required by the simplified computational sub-flow is less than the amount of computational resources required by the unsimplified computational sub-flow; Step S108, mapping the simplified computational sub-flow to the corresponding computational unit to obtain a set of computational units; Step S110, fusing the computational units contained in the set of computational units, and generating a target model corresponding to the original model based on the fusion result, wherein different computational sub-flows of the target model need to be processed using matching computational resources.

[0042] Optionally, after generating the target model corresponding to the updated original model according to steps S102 to S110, when it is necessary to analyze historical behavior information and generate service information, the historical behavior information of the target object to be recommended for service information can be read from database 108. That is, the historical behavior information of the target object is also stored in the database on the cloud server. The historical behavior information in the database is input into the updated model to be processed for inference, which can generate service information that matches the target object. After the service information is obtained through inference, the service information can be recommended to the target object's terminal device 102 through network 104 and can be displayed on the terminal device.

[0043] Using the above method, the computational flow describing the computational resources required to run the original model can be identified. Computational sub-flows can be identified from this flow, and simplified based on the amount of computational resources required, resulting in simplified sub-flows with fewer resources. These sub-flows can then be mapped to corresponding computational units for fusion processing, generating a fusion result. Based on the fusion result, a target model corresponding to the original model can be generated, thus updating the original model based on the fusion result. Since the original model contains numerous computational flows that cause many problems, by focusing on the computational sub-flows and their required resources, these problems can be avoided, thereby improving data processing efficiency and solving the problem of low data processing efficiency.

[0044] Figure 2 This is a structural block diagram of a computing environment for a data processing method according to an embodiment of this application, such as... Figure 2 As shown, computing environment 201 includes multiple computing nodes (such as servers) running on a distributed network (shown as 210-1, 210-2, ... in the diagram). Each computing node contains local processing and memory resources, and end user 202 can remotely run applications or store data within computing environment 201. Applications can be provided as multiple services 220-1, 220-2, 220-3, and 220-4 within computing environment 201, representing services "A", "D", "E", and "H", respectively.

[0045] End user 202 can provide and access services through a web browser or other software application on a client. In some embodiments, the provisioning and / or requests of end user 202 can be provided to ingress gateway 230. Ingress gateway 230 may include a corresponding agent to handle the provisioning and / or requests for services (one or more services provided in computing environment 201).

[0046] Services are provided or deployed based on various virtualization technologies supported by the Computing Environment 201. In some embodiments, services may be provided based on Virtual Machine (VM)-based virtualization, container-based virtualization, and / or similar methods. Virtual Machine-based virtualization can simulate a real computer by initializing a virtual machine, executing programs and applications without directly accessing any actual hardware resources. While the virtual machine virtualizes the machine, container-based virtualization can launch containers to virtualize an entire operating system (OS), allowing multiple workloads to run on a single OS instance.

[0047] In one embodiment based on container virtualization, several containers of a service can be assembled into a Pod (e.g., a Kubernetes Pod). For example, such as Figure 2 As shown, service 220-2 can be equipped with one or more Pods 240-1, 240-2, ..., 240-N (collectively referred to as Pods). A Pod can include a proxy 245 and one or more containers 242-1, 242-2, ..., 242-M (collectively referred to as containers). One or more containers within a Pod handle requests related to one or more corresponding functions of the service. Proxy 245 typically controls service-related network functions such as routing and load balancing. Other services can also be equipped with Pods similar to Pods.

[0048] During operation, executing a user request from end user 202 may require invoking one or more services in computing environment 201, and executing one or more functions of one service may require invoking one or more functions of another service. For example... Figure 2 As shown, service "A" 220-1 receives user requests from terminal user 202 from ingress gateway 230. Service "A" 220-1 can call service "D" 220-2, and service "D" 220-2 can request service "E" 220-3 to perform one or more functions.

[0049] The aforementioned computing environment can be a cloud computing environment, where resource allocation is managed by cloud services, allowing functionality development without needing to consider implementation, adjustment, or server scaling. This computing environment allows developers to execute event-responsive code without building or maintaining complex infrastructure. Services can be partitioned into a set of functions that can automatically and independently scale, rather than scaling a single hardware device to handle potential loads.

[0050] Under the aforementioned operating environment, this application provides the following: Figure 3 The data processing method shown is illustrated. It should be noted that the data processing method in this embodiment can be derived from... Figure 1The computer device of the illustrated embodiment is executed. Figure 3 This is a flowchart of a data processing method according to an embodiment of this application, such as... Figure 3 As shown, the method may include the following steps:

[0051] Step S302: Obtain the computational flow describing the original model, wherein computational resources are required to complete the computational flow when running the original model.

[0052] In the technical solution provided in step S302 of this application, if it is necessary to process the original model to update it, the computational flow of the original model can be obtained. Running the original model requires computing resources to complete the computational flow. The original model can be a model to be processed with a deep neural network, such as a deep recommendation model with a large number of embedding columns. This deep recommendation model can be a model used to recommend services or products that match the preferences and needs of a target audience. This is merely an example and does not limit the specific model to be processed. Any model with a deep neural network that has problems caused by a large number of embedding columns is within the protection scope of this application's embodiments.

[0053] In this embodiment, the original model may include two parts: a deep neural network stack and an embedding layer. The embedding layer may include at least one embedding column corresponding to different feature fields in the original model; for example, the embedding layer consists of at least one such embedding column. The embedding column can also be called an embedding table, and this computational flow can be used to represent the computational flow between the deep neural network in the original model and the embedding layer of the original model. The computational flow can be the concatenation process and method between the deep neural network and the embedding layer, and can be represented by the computational graph of the corresponding original model. The embedding layer may contain at least one embedding column from the original model.

[0054] Optionally, when a model with a deep neural network needs to undergo embedding layer processing, this model can be identified as the original model to be processed. Embedding vectors (embedding columns) can be concatenated with the deep neural network in this original model to generate a corresponding computational graph. The embedding columns can be the embedding vectors transformed from features in the input original model by processing and querying an embedding table. The embedding columns of this original model constitute the embedding layer of the original model.

[0055] Step S304: Identify at least one calculation sub-process from the calculation process.

[0056] In the technical solution provided in step S304 of this application, after obtaining the computational flow describing the original model, computational sub-flows can be identified from the computational flow. These computational sub-flows can be embedding columns in the embedding layer. Embedding columns can be used to convert the features to be processed in the deep neural network into computational subgraphs in the computational graph. The features to be processed can be input features, feature fields, or statistical features, etc., which are only examples and not specifically limited. Embedding columns can be embedding column subgraphs identified from the computational graph. Embedding column subgraphs can include various nodes, such as tensor computation nodes, shape computation nodes, etc., which are only examples and not specifically limited. Computational subgraphs can be used to represent subgraphs generated during the adjustment of embedding columns, such as subgraphs generated during tensor computation of embedding column subgraphs, subgraphs generated during shape computation reconstruction, and subgraphs generated during redundancy removal and simplification. It should be noted that the content included in the above computational subgraphs is only illustrative and does not impose specific limitations on the computational subgraphs.

[0057] Optionally, this embodiment can identify the computational process in the original model and identify at least one computational sub-process from the computational process. That is, it can identify and decompose the embedded column of the original model computation graph, decompose at least one embedded column from the embedded layer of the computation graph, and perform calculations for each embedded column to convert the features to be processed in each embedded column into a computational sub-graph of the computation graph.

[0058] Step S306: Simplify the different calculation sub-processes, wherein the simplified calculation sub-processes require less computing resources than the original calculation sub-processes.

[0059] In the technical solution provided by step S306 of this application, after identifying at least one computational subprocess from the computational process, each computational subprocess can be simplified. That is, the amount of computational resources required in the computational subprocess can be reduced to obtain a simplified computational subprocess with lower computational resource requirements. The amount of computational resources required by the simplified computational subprocess can be less than the amount of computational resources required by the simplified computational subprocess.

[0060] Alternatively, this embodiment derives a symbolic expression for the shape of all tensors corresponding to the feature to be processed for each embedding column.

[0061] Optionally, the embedded subgraph can be reconstructed through unified shape calculation. That is, the embedded subgraph derived from symbolic expressions is replaced with a unified operator for simplification, resulting in a new reconstructed embedded subgraph. Redundancy security measures can be removed and embedding lookup simplified on the reconstructed embedded subgraph to obtain a simplified embedded subgraph.

[0062] In this embodiment, the presence of numerous embedding columns in the original model presents several problems, leading to low data processing efficiency. In this embodiment, all embedding columns in the embedding layer can be identified from the computation graph of the original model. These embedding columns can then be used to convert the features to be processed into computational subgraphs. This conversion process essentially involves adjusting the embedding column subgraph at the graph level, simplifying it. Therefore, by simplifying the embedding column subgraph, the corresponding computational subgraph is obtained, thereby achieving the goal of simplifying the embedding column subgraph and ultimately improving data processing efficiency.

[0063] Step S308: Map the simplified calculation sub-processes to the corresponding calculation units to obtain a set of calculation units.

[0064] In the technical solution provided in step S308 of this application, after simplifying the computational sub-process to obtain the simplified computational sub-process, the simplified computational sub-process can be mapped to the corresponding computational units to form a set of computational units. The computational unit can be a processor used to run the computational sub-process using computational resources, and can be a Graphics Processing Unit (GPU) or a Central Processing Unit (CPU). The processor and the computational resources required by the embedded column are matched. The embedded column can be a computational operation performed by the processor based on computational resources. The set of computational units can be used to represent the set formed after all computational sub-processes are mapped to the required computational units.

[0065] Optionally, after identifying the computational sub-process, that is, after obtaining the embedded columns in the embedded layer by identifying the computational graph, a processor that matches the computational resources required by the embedded column can be determined, so that the embedded column can be mapped to the corresponding processor, and the processor can use the computational resources to perform computational operations on the received embedded column.

[0066] In this embodiment, the embedded column can be analyzed to determine which processor needs to perform the computational operation on it. For example, if the size of the embedded table contained in the embedded column reaches a certain threshold, the entire embedded column can be mapped to the CPU for processing. Based on the above-mentioned CPU and GPU co-operation mode, different embedded columns or their corresponding operators can be selectively placed on suitable processors according to actual needs to perform computational operations. This reduces video memory overhead, fully utilizes idle CPU computing resources, and improves computing resource utilization, thereby achieving the technical effect of improving data processing efficiency and solving the technical problem of low data processing efficiency.

[0067] After mapping the embedded column to the corresponding processor, this embodiment can use the processor to perform calculation operations on the embedded column according to the computing resources required by the embedded column, determine the calculation result corresponding to the embedded column, and then update the model to be processed according to the calculation result.

[0068] Optionally, by performing simplification operations on each embedded column and performing corresponding calculation operations on the processed embedded columns, the corresponding calculation results can be obtained. The calculation results can be used to update the original model to be processed. For example, kernel functions or operators corresponding to the embedded columns can be added to the corresponding positions in the original model to be processed, thereby updating the model to be processed.

[0069] Step S310: The computing units contained in the computing unit set are fused, and the original model is updated based on the fusion result to generate a target model corresponding to the original model. Different computing sub-processes of the target model need to be processed using matching computing resources.

[0070] In the technical solution provided by step S310 of this application, after the simplified calculation sub-process is mapped to the corresponding calculation unit, the calculation units contained in the calculation unit set can be fused to obtain the fusion result, and the corresponding target model can be generated according to the fusion result. Different calculation sub-processes in the target model can be processed using matching calculation resources.

[0071] Optionally, this embodiment can fuse all the simplified embedding subgraphs in the embedding layer to obtain a fused operator. For example, the embedding subgraphs can be fused using a parallelism-oriented fusion method.

[0072] It should be noted that the above-described process and method for fusing embedded column subgraphs are merely illustrative examples. Any process and method used to calculate and simplify all embedded layer subgraphs in the embedded column are within the protection scope of the embodiments of this application, and will not be described in detail here.

[0073] Through steps S302 to S310 of this application, the original model can be identified to determine the computational flow that describes the computational resources required to run the original model. Computational sub-flows can be identified from the computational flow, and the computational flow can be simplified according to the amount of computational resources required, resulting in simplified computational sub-flows with fewer computational resources. These computational sub-flows can be mapped to corresponding computational units for fusion processing to generate a fusion result. Based on the fusion result, a target model corresponding to the original model can be generated, thereby achieving the purpose of updating the original model based on the fusion result. Since the original model contains numerous computational flows that cause many problems, by calculating the computational sub-flows and their required computational resources, the problem of redundant computation leading to reduced model performance caused by numerous computational flows can be avoided. This achieves the technical effect of improving data processing efficiency and solves the technical problem of data processing efficiency.

[0074] The method described in this embodiment will be further described below.

[0075] As an optional implementation, step S304, identifying at least one computational sub-process from the computational process, includes: decomposing the computational process to identify at least one variable of the original model, wherein the variable represents trainable data in the original model and matches the type of the computational sub-process; and determining the computational sub-process based on the variable. The type of the computational sub-process can be an operator type.

[0076] In this embodiment, the computation process can be broken down and identified to obtain at least one variable in the original model, and the computation sub-processes in the computation process can be determined based on the variable. The variable can be used to represent trainable data in the original model that matches the type of the computation sub-process. For example, the variable can be a trainable variable or an embedded table variable.

[0077] Optionally, the computation graph can be identified to obtain at least one embedding table of the original model, and embedding columns can be determined based on the embedding table, wherein the operation information corresponding to the embedding table can be associated with the embedding columns.

[0078] As an optional implementation, determining the computational sub-process based on variables includes: determining the initial computational sub-process corresponding to the variable; and updating the computational sub-process to a new computational sub-process using the predecessor computational nodes of the computational nodes in the initial computational sub-process.

[0079] In this embodiment, an initial computational sub-process corresponding to a variable can be determined. Then, the predecessor computational nodes of the computational nodes in the initial computational sub-process are used to modify and update the initial computational sub-process. The initial computational sub-process can be the initialization of the embedded column subgraph corresponding to the current embedded table. The computational nodes can be nodes in the embedded column subgraph, including precursor computational nodes and successor computational nodes. The precursor computational node can also be called a predecessor computational node. The successor computational node can also be called a successor node.

[0080] Optionally, the computation graph corresponding to the entire original model can be decomposed into embedding columns. For example, all embedding tables in the computation graph can be decomposed based on the operator type applied after the trainable variables. For all nodes in the computation graph, the number of embedding tables contained in the direct or indirect predecessor nodes can be counted. All embedding tables in the original model can be traversed. For each embedding table, the embedding column subgraph corresponding to each embedding table can be initialized, or a queue for breadth-limited traversal can be initialized. It can be determined whether the queue is not empty. If it is, the node can be dequeued from the queue, and all successor nodes of the node can be traversed. For each successor node, it can be determined whether the number of predecessor embedding tables of the successor node is less than or equal to 1. If it is less than or equal to 1, the successor node can be inserted into the current embedding column subgraph. If it is greater than 1, other successor nodes can be traversed until the traversal is complete. If not, all nodes in the current embedding column subgraph can be traversed further. For each node, the corresponding predecessor node can be traversed, and each predecessor node can be inserted into the current embedding column subgraph. After all predecessor nodes have been traversed, other nodes in the current embedded subgraph can be traversed. After all nodes have been traversed, it can be determined whether the embedded subgraph has been updated in this iteration.

[0081] As an optional implementation, the method may further include: determining the processing type corresponding to the computational sub-process of the target model, wherein the processing type is used to represent the type of operation to be performed on the computational sub-process of the target model; and determining, based on the processing type, the matching computational resources required for the computational sub-process of the target model.

[0082] In this embodiment, the processing type corresponding to the computational sub-process of the target model can be determined, and the computing resources and corresponding processors to be matched to the computational sub-process in the target model can be determined according to the processing type. The processing type can be used to indicate the type of operation to be performed on the computational sub-process of the target model.

[0083] Alternatively, in this embodiment, embedded columns can be mapped to thread blocks of the processor, wherein the thread blocks are used to constitute the kernel functions run by the processor's kernel.

[0084] Optionally, embedded columns can be mapped to processor thread blocks, where thread blocks can be used to construct kernel functions to be executed by the processor's kernel; these can also be called GPU thread blocks or GPU functions. The kernel can be the GPU kernel.

[0085] Optionally, each embedded column obtained through simplification and other processes can be mapped to a corresponding GPU thread block. The embedded columns can be processed on the thread block to obtain the corresponding kernel function that can run in the processor's core.

[0086] Optionally, operators corresponding to at least one embedded column can be fused to obtain a kernel function.

[0087] Optionally, before mapping the embedded columns to the corresponding thread blocks of the processor, the individual embedded columns, after a series of graph-level adjustments and steps, can be merged into a single GPU function.

[0088] Optionally, for each embedding column, a symbolic expression for the shape of all tensors corresponding to the features to be processed can be derived. The embedding column subgraph can be reconstructed using unified shape computation to obtain a new reconstructed embedding column subgraph. Redundancy removal and embedding lookup simplification can be performed on the reconstructed embedding column subgraph to obtain a simplified embedding column subgraph. All simplified embedding column subgraphs in the embedding layer can be fused to obtain a fused operator. The fused operator can be converted into a fused kernel function using a Compute Unified Device Architecture (CUDA), for example, fusion can yield Block 1, ..., Block N. In this embodiment, by simplifying the embedding column subgraph to obtain the corresponding computational subgraph, and fusing the simplified operators corresponding to all embedding columns, the fused operator can be processed to obtain the corresponding fused kernel function, thereby achieving the purpose of simplifying the embedding column subgraph and thus improving the technical effect of data processing efficiency.

[0089] In the embodiments of this application, a large number of embedded columns can be merged into a single kernel function, and each embedded column is processed by a CUDA Block. This fusion method can not only eliminate the non-computational overhead caused by the synchronization of a large number of kernel functions and operator scheduling, but also fully explore the parallelism between subgraphs and within operators in the model to be processed, thereby achieving the technical effect of making full use of the computing resources in the GPU.

[0090] As an optional implementation, based on the processing type, determining that the computational sub-process of the target model requires matching computational resources includes: in response to a string operation to be performed on the computational sub-process of the target model, determining to call computational resources in the central processing unit; in response to a non-string operation to be performed on the computational sub-process of the target model, determining to call computational resources in the graphics processing unit.

[0091] In this embodiment, the processing type can be determined. When the processing type is a calculation sub-process of the target model awaiting string operation, it is determined that computing resources in the central processing unit can be called. When the processing type is a calculation sub-process of the target model awaiting non-string operation, it is determined that computing resources in the graphics processing unit (GPU) can be called. The GPU can also be referred to as an image processor.

[0092] Optionally, based on the operation information of the embedded column, the embedded column can be mapped to the corresponding processor. The operation information can be used to characterize whether a string operation is performed on the embedded column, and may include information on operations such as Gather.

[0093] For example, if a string operation is performed on the embedded column, that embedded column can be mapped to the CPU. If no string operation is performed on the embedded column, it can be mapped to the GPU. It should be noted that this is merely an example and does not impose specific limitations on the operation information or the methods and processes by which operation information is mapped to the corresponding processor.

[0094] In this embodiment, after obtaining the kernel function, the operation information in the embedded column can be analyzed to determine which processor the embedded column needs to execute computational operations on. Based on the above-mentioned CPU and GPU co-operation mode, different embedded columns or their corresponding operators can be selectively placed into suitable processors for computational operations according to actual needs, thereby reducing video memory overhead and fully utilizing the computing resources in idle CPUs, thus achieving the technical effect of improving data processing efficiency.

[0095] As an optional implementation, the method may further include: determining to call computing resources in the central processing unit in response to the data volume of the variable corresponding to the computational sub-process of the target model being greater than a data volume threshold; and determining to call computing resources in the graphics processing unit in response to the data volume of the variable corresponding to the computational sub-process of the target model not being greater than a data volume threshold.

[0096] In this embodiment, the size of the data volume of the variables corresponding to the calculation sub-process of the target model can also be determined. If the data volume is greater than a threshold, the computing resources in the central processing unit can be called for processing. If the data volume is less than or equal to the threshold, the computing resources in the graphics processing unit can be called for processing. The data volume can be used to represent the size of the embedded table in bytes, which can be megabytes (Mb byte, abbreviated as MB). The data volume threshold can be a pre-set value of the embedded table in bytes, or it can be a value of bytes set according to the actual size of the embedded column. For example, the size threshold can be set to 256MB in advance.

[0097] It should be noted that the above-mentioned data volume threshold size and setting method are only illustrative examples and are not specifically limited here. Any method and steps that analyze the operation information of the embedded column to determine which processor the embedded column should be mapped to are within the protection scope of the embodiments of this application.

[0098] Optionally, in this embodiment, not only can the operation information be judged, but also the data volume of the variable corresponding to the embedded table of the embedded column can be judged. If it is determined that the operation information is that no string operation was performed on the embedded column, and during the calculation operation on the embedded table corresponding to the embedded column, the data volume is less than or equal to the data volume threshold, the embedded column can be mapped to the corresponding graphics processor. If it is determined that the operation information is that a string operation was performed on the embedded column, or the data volume is greater than the data volume threshold, the embedded column can be mapped to the corresponding central processing unit.

[0099] Optionally, a portion of the deep neural networks (DNNs) in the original model can be placed on the GPU. All embedding layers in the original model can be traversed. For each embedding column, the amount of data in the embedding table of each embedding column can be determined. If the amount of data in the embedding table of that embedding layer is greater than a data volume threshold, then the entire embedding column can be mapped to the CPU.

[0100] Optionally, if the amount of data in the variables of the embedding layer is less than or equal to the data amount threshold, all operators contained in the embedding column can be traversed. For each operator, it can be determined whether each operator belongs to string operations. If it belongs to string operations, the operator belonging to string operations can be mapped to the CPU. After mapping the operator, it is possible to continue traversing other operators in the embedding column until the traversal ends. If the current operator does not belong to string operations, the operator that does not belong to string operations can be mapped to the GPU.

[0101] Alternatively, operators that map all embedded columns to the GPU can be merged into a single kernel function.

[0102] In the embodiments of this application, based on the above-mentioned method of CPU and GPU running together, different embedding columns or operators corresponding to the embedding columns can be placed in suitable processors to perform calculation operations according to actual needs, thereby reducing video memory overhead and making full use of the computing resources in the idle CPU, thereby achieving the technical effect of improving data processing efficiency.

[0103] As an optional implementation, different computational sub-processes are simplified, including: reconstructing the computational sub-processes based on the description information of tensors in the computational sub-processes to obtain target computational sub-processes, wherein the description information is used to describe the properties of tensors, and the amount of computational resources required by the target computational sub-processes is less than the amount of computational resources required by the computational sub-processes.

[0104] Optionally, if simplification of the computational sub-process is required, it can be reconstructed based on the tensor description information within the sub-process to obtain the target computational sub-process. The description information can be a symbolic expression of the tensor's shape. The target computational sub-process requires fewer computational resources than the original computational sub-process. Reconstruction can simplify the computation graph by replacing operators with uniform operators.

[0105] Optionally, for each embedding column in the embedding layer, a symbolic expression for the shape of all tensors in the embedding column subgraph of the embedding column can be derived at the graph level. For example, in the embedding column subgraph, the symbolic expression corresponding to all tensor computation nodes can be determined as follows: <n0> 、 <n1>,<n0,8> Etc. It should be noted that the symbolic expressions for the tensor computation nodes mentioned above are for illustrative purposes only and are not subject to specific limitations.

[0106] Optionally, the shape calculation subgraph containing all the shape calculation nodes in the embedded column subgraph can be determined. The shape calculation subgraph can be replaced by a unified operator, namely a unified shape construction node, thereby simplifying the embedded layer subgraph.

[0107] For example, after deriving the symbolic expressions for the shapes of all tensors in the embedded column subgraph, all shape computation nodes with redundant shape computation information in the target embedded column subgraph can be replaced with uniform shape construction nodes. This initially removes redundant computation information from the shape computation nodes. Subsequently, a second simplification can be performed to remove tensor computation nodes with redundant tensor computation information from the embedded column subgraph. This second removal of redundant computation information from the tensor computation nodes yields the embedded columns that do not include redundant computation information.

[0108] Optionally, the embedded column can be adjusted to remove redundant computational information, resulting in an embedded column that does not include redundant computational information. The operators corresponding to the embedded column can then be fused to obtain the kernel function corresponding to the embedded column. Adjusting the embedded column can be a graph-level adjustment of the embedded column subgraph. The redundant computational information can be redundant shape computation information or redundant tensor computation information, etc.

[0109] It should be noted that the above redundant calculation information is only an example. Any process and method used to delete redundant calculation information to simplify the embedded column is within the protection scope of the embodiments of this application, and will not be described in detail here.

[0110] Optionally, the embedded columns in the embedding layer can be identified and analyzed to obtain all the embedded layers included in the embedding layer. For each embedded column subgraph, a symbolic expression for the shape of all tensors can be derived. Then, the embedded column subgraph derived from the symbolic expression can be replaced with a unified operator to simplify the embedded column subgraph; that is, redundant computational information in the embedded column subgraph can be initially removed to obtain a preliminarily simplified embedded column subgraph. Redundancy safety protection removal and embedding lookup simplification can be performed on the preliminarily simplified embedded column subgraph; that is, redundant computational information in the preliminarily simplified embedded column subgraph can be removed a second time to obtain a second-simplified embedded column subgraph, i.e., an adjusted embedded column that does not contain redundant computational information. All simplified embedded column subgraphs in the embedding layer can be merged to obtain a merged operator. Further, a merged kernel function can be obtained.

[0111] For example, after deriving the symbolic expressions for the shapes of all tensors in the embedded column subgraph, all shape computation nodes with redundant shape computation information in the target embedded column subgraph can be replaced with unified shape construction nodes. That is, redundant computation information in the shape computation nodes is initially removed. Subsequently, through secondary simplification, tensor computation nodes with redundant tensor computation information in the embedded column subgraph are deleted. That is, redundant computation information in the tensor computation nodes is removed a second time, thus obtaining an embedded column that does not include redundant computation information. It should be noted that the above-described process and method for deleting redundant computation information in the embedded column are all within the protection scope of the embodiments of this application.

[0112] As an optional implementation, the simplified calculation sub-process is mapped to the corresponding calculation unit to obtain a set of calculation units, including: mapping the target calculation sub-process after removing redundant data information and / or simplifying data lookup information to the corresponding calculation unit to obtain a set of calculation units.

[0113] In this embodiment, redundant data information in the target computation sub-process can be removed, and / or data lookup information in the target computation sub-process can be simplified. The processed target computation sub-process can be mapped to corresponding computation units, thereby obtaining a set of computation units. The processor may contain thread blocks used to map the target computation sub-process. Data security information can be used to characterize the data security performance of the embedded column and can remove redundant security safeguards in the embedded column. Data lookup information can be used to find the data embedded in the embedded column. The data embedded in the embedded column can be the embedded lookup portion.

[0114] Optionally, the embedded columns, after being adjusted to remove redundant data information and / or simplify data lookup information, can be mapped to the processor's thread blocks.

[0115] Optionally, the various embedded columns obtained after a series of graph-level adjustments such as simplification and unification operators can be merged into a GPU kernel function, and each embedded column can be mapped onto a GPU Block.

[0116] In this embodiment, by performing a series of graph-level adjustments on the embedded columns, such as simplifying shape calculations, removing redundant security safeguards, and simplifying embedded lookups, the embedded columns can be simplified and adjusted on the layer surface. This achieves the goal of avoiding a series of problems associated with a large number of embedded columns. If the simplified and adjusted embedded columns are mapped to the processor's thread block, the simplified and adjusted embedded columns can be used to update the model to be processed, thereby achieving the technical effect of improving data processing efficiency.

[0117] Optionally, the embedded column can be adjusted at the graph level, or the computational subgraph corresponding to the embedded column can be adjusted based on the context of the embedded column.

[0118] Alternatively, the computation subgraph can be adjusted by analyzing the context in the embedded column to eliminate redundant computation information.

[0119] Optionally, adjustments can be made at the graph level of the embedded column, that is, the embedded column subgraph can be adjusted to simplify and adjust the embedded column subgraph.

[0120] Optionally, the embedded column can be adjusted at the graph level using at least one of the following methods: The computational subgraph corresponding to the tensor description information in the embedded column can be converted into the target operator. Data security information in the embedded column can be removed. Data lookup information in the embedded column can be simplified.

[0121] Alternatively, redundant security safeguards (data security information) in the embedded column can be removed.

[0122] Optionally, the embedded lookup portion of the embedded column subgraph can be simplified.

[0123] The presence of numerous embedded columns in the model to be processed presents numerous problems, leading to low data processing efficiency. However, in this embodiment, all embedded columns in the embedding layer can be adjusted at the graph level through a series of graph-level adjustments, including computational simplification, removal of redundant security safeguards, and simplification of embedding lookup. This simplifies the computation of the embedded columns. Therefore, by simplifying the embedded column subgraph, a corresponding computational subgraph is obtained, and the simplified computational subgraphs corresponding to all embedded columns are merged, thereby simplifying the embedded column subgraph and improving data processing efficiency.

[0124] In this embodiment, the original model can be identified to determine the computational flow that requires computing resources to run it. Computational sub-flows can be identified from this flow, and simplified based on the amount of computing resources required, resulting in simplified sub-flows with fewer resources. These sub-flows can be mapped to corresponding computing units for fusion processing, generating a fusion result. The target model corresponding to the original model can be generated based on the fusion result, thus updating the original model. Since the original model contains numerous computational flows, many problems arise. By calculating the computational sub-flows and their required computing resources, the performance degradation caused by redundant computations introduced by numerous computational flows can be avoided, thereby improving data processing efficiency and solving the problem of low data processing efficiency.

[0125] This application provides another data processing method on the Software as a Service (SaaS) side. Figure 4 This is a flowchart of another data processing method according to an embodiment of this application, such as... Figure 4 As shown, the method may include the following steps:

[0126] Step S402: Obtain the computational process describing the original model by calling the first interface. The first interface includes a first parameter, the value of which is the computational process. Computational resources are required to complete the computational process when running the original model.

[0127] In the technical solution provided in step S402 of this application, the computational flow of the original model can be obtained by calling a first interface. The first interface may include a first parameter, the value of which can be the computational flow. The original model may include a deep neural network and an embedding layer. The computational flow can be represented by a computation graph, which can be used to at least describe the computational flow between the deep neural network and the embedding layer. Running the original model requires computational resources to complete the computational flow.

[0128] Optionally, if it is necessary to process a certain deep neural network model, which is the original model, the first interface can be called through the corresponding calling instruction to analyze the received original model and determine the corresponding calculation process.

[0129] Step S404: Identify at least one calculation sub-process from the calculation process.

[0130] In the technical solution provided by step S404 of this application, the calculation process can be identified, and at least one calculation sub-process can be determined.

[0131] Optionally, the obtained computation graph can be identified to identify all embedding columns in the embedding layer of the computation graph, wherein the embedding columns can be used to convert the features to be processed in the deep neural network into computation subgraphs of the computation graph.

[0132] Optionally, this embodiment can identify the computational process in the original model and identify at least one computational sub-process from the computational process. That is, it can identify and decompose the embedded column of the original model computation graph, decompose at least one embedded column from the embedded layer of the computation graph, and perform calculations for each embedded column to convert the features to be processed in each embedded column into a computational sub-graph of the computation graph.

[0133] Step S406: Simplify the different calculation sub-processes, wherein the simplified calculation sub-processes require less computing resources than the original calculation sub-processes.

[0134] In the technical solution provided by step S406 of this application, different calculation sub-processes can be simplified, wherein the amount of computing resources required by the simplified calculation sub-process is less than the amount of computing resources required by the calculation sub-process before simplification.

[0135] Alternatively, this embodiment derives a symbolic expression for the shape of all tensors corresponding to the feature to be processed for each embedding column.

[0136] Optionally, the embedded subgraph can be reconstructed through unified shape calculation. That is, the embedded subgraph derived from symbolic expressions is replaced with a unified operator for simplification, resulting in a new reconstructed embedded subgraph. Redundancy security measures can be removed and embedding lookup simplified on the reconstructed embedded subgraph to obtain a simplified embedded subgraph.

[0137] Optionally, all embedding columns in the embedding layer can be identified from the computation graph of the original model. These embedding columns can then be used to convert the features to be processed into computational subgraphs. This conversion process is equivalent to adjusting the embedding column subgraphs at the graph level, thus simplifying them. Therefore, by simplifying the embedding column subgraphs to obtain the corresponding computational subgraphs, and then fusing the simplified computational subgraphs corresponding to all embedding columns, the goal of simplifying the embedding column subgraphs is achieved, thereby improving the technical effect of data processing efficiency.

[0138] Step S408: Map the simplified calculation sub-processes to the corresponding calculation units to obtain a set of calculation units.

[0139] In the technical solution provided by step S408 of this application, the simplified calculation sub-process can be mapped to the corresponding calculation unit, thereby obtaining a set of calculation units.

[0140] Optionally, embedded columns can be mapped to corresponding processors, where the processor can be matched with the computational resources required by the embedded column. The embedded column can be a computational operation performed by the processor based on the computational resources.

[0141] Optionally, after identifying the computational sub-process, that is, after obtaining the embedded columns in the embedded layer by identifying the computational graph, a processor that matches the computational resources required by the embedded column can be determined, so that the embedded column can be mapped to the corresponding processor, and the processor can use the computational resources to perform computational operations on the received embedded column.

[0142] Step S410: The computing units contained in the computing unit set are fused, and a target model corresponding to the original model is generated based on the fusion result. Different computing sub-processes of the target model need to be processed using matching computing resources.

[0143] In the technical solution provided by step S410 of this application, the computing units in the computing unit set can be fused, and a target model corresponding to the original model can be generated based on the fusion result. Different computing sub-processes of the target model need to be processed using matching computing resources.

[0144] Optionally, this embodiment can fuse all the simplified embedding subgraphs in the embedding layer to obtain a fused operator. For example, the embedding subgraphs can be fused using a parallelism-oriented fusion method.

[0145] Optionally, the kernel function corresponding to the operator after the computation subgraph of all embedded columns is determined by CUDA, and the kernel function can be mapped to the processor.

[0146] Optionally, after obtaining the kernel function, the embedded columns can be analyzed to determine which processor the computational operation needs to be performed on. For example, if the size of the embedded table contained in the embedded column reaches a certain threshold, the entire embedded column can be mapped to the CPU for processing. Based on the above-mentioned CPU and GPU co-operation method, different embedded columns or their corresponding operators can be selectively placed on suitable processors according to actual needs, thereby reducing video memory overhead and fully utilizing the computing resources in idle CPUs, thus achieving the technical effect of improving data processing efficiency.

[0147] Step S412: Output the target model by calling the second interface, wherein the second interface includes a second parameter, and the parameter value of the second parameter is the target model.

[0148] In the technical solution provided by step S412 of this application, the target model can be output by calling the second interface. The second interface may include a second parameter, and the parameter value of the second parameter can be the target model.

[0149] Through steps S402 to S412 of this application, a computational flow describing the original model is obtained by calling a first interface, wherein the first interface includes a first parameter whose value is the computational flow. Computational resources are required to complete the computational flow when running the original model. At least one computational sub-flow is identified from the computational flow. Different computational sub-flows are simplified, wherein the simplified computational sub-flow requires less computational resources than the unsimplified computational sub-flow. The simplified computational sub-flows are mapped to corresponding computational units to obtain a set of computational units. The computational units contained in the set of computational units are fused, and a target model corresponding to the original model is generated based on the fusion result. Different computational sub-flows of the target model require matching computational resources for processing. The target model is output by calling a second interface, wherein the second interface includes a second parameter whose value is the target model. This achieves the technical effect of improving data processing efficiency and solves the technical problem of low data processing efficiency.

[0150] This application also provides an information recommendation method from the application side. Figure 5 This is a flowchart of an information recommendation method according to an embodiment of this application, such as... Figure 5 As shown, the method may include the following steps:

[0151] Step S502: Obtain the computational process used to describe the original recommendation model, wherein the original recommendation model is used to determine the service information to be recommended to the target object, and computing resources are required to complete the computational process when running the original recommendation model.

[0152] In the technical solution provided in step S502 of this application, the computational process of obtaining the original recommendation model to be processed can be described. The recommendation model can be used to recommend service information to the target object based on the target object's historical behavior information, and can include a deep neural network and an embedding layer. It can be a deep neural network model, also known as a deep recommendation model. The computational process can be represented by a computational graph. The computational graph can be used to at least describe the computational process between the deep neural network and the embedding layer. The target object can be a customer or user who needs recommended service information. Historical behavior information can be information such as the name, type, and price of documents previously read, purchase links browsed, videos watched, or items liked and added to cart by the target object. It should be noted that the above historical behavior information is only illustrative and is not specifically limited here. Any information that can analyze the target object's preferences and recommend corresponding service information to the target object is within the protection scope of this application's embodiments. Service information can be used to represent information that meets the target object's preferences and needs, such as videos recommended to the target object, items to be purchased, etc., which are only illustrative and are not specifically limited here.

[0153] As an alternative example, historical behavior information of a target object can be input into a deep recommendation model. The deep recommendation model can then analyze this historical behavior information and recommend service information that matches the target object's preferences. However, the process of inferring service information using a deep recommendation model is very time-consuming, and the large number of embedding columns in the model degrades the performance of the recommended service information, resulting in low processing efficiency. To improve the processing efficiency of the deep recommendation model and address the problem of numerous embedding columns, this embodiment of the application can perform corresponding simplification processing on the embedding layer at the graph level, thereby avoiding a series of problems caused by embedding columns.

[0154] Step S504: Simplify the different calculation sub-processes, wherein the simplified calculation sub-processes require less computing resources than the original calculation sub-processes.

[0155] In the technical solution provided in step S504 of this application, after obtaining the calculation process of the original recommendation model to be processed, the calculation process can be identified, the calculation sub-processes can be determined, and different calculation sub-processes can be simplified. The amount of computing resources required by the simplified calculation sub-process can be less than the amount of computing resources required by the original calculation sub-process.

[0156] Optionally, by identifying the computation graph, all embedding columns in the embedding layer can be determined, whereby the embedding columns can be used to transform the features to be processed in the deep neural network into computation subgraphs of the computation graph.

[0157] Optionally, the computation graph can be embedded column identified, at least one embedded column can be identified from the embedding layer in the computation graph, and computation can be performed for each embedded column to convert the features to be processed in each embedded column into a computation subgraph of the computation graph.

[0158] Step S506: Map the simplified calculation sub-processes to the corresponding calculation units to obtain a set of calculation units.

[0159] In the technical solution provided by step S506 of this application, the simplified calculation sub-process can be mapped to the corresponding calculation unit to obtain a set of calculation units.

[0160] Optionally, after identifying the computation graph and obtaining at least one embedded column of the embedded layer, the embedded column can be mapped to the corresponding processor, wherein the processor can be matched with the computational resources required by the embedded column, and the embedded column can be a computational operation performed by the processor based on the computational resources.

[0161] Optionally, the kernel function corresponding to the operator after the computation subgraph of all embedded columns is determined by CUDA, and the kernel function can be mapped to the processor.

[0162] Step S508: The computing units contained in the computing unit set are fused, and a target recommendation model corresponding to the original recommendation model is generated based on the fusion result. Different computing sub-processes of the target recommendation model need to be processed using matching computing resources to generate service information.

[0163] In the technical solution provided in step S508 of this application, the computing units contained in the computing unit set can be fused to obtain a fusion result. The fusion result can then be processed to generate a target recommendation model corresponding to the original recommendation model. Different computational sub-processes of the target recommendation model require matching computing resources for processing to generate service information.

[0164] Optionally, for each embedding column, a symbolic expression for the shape of all tensors corresponding to the features to be processed can be derived. The embedding column subgraph can be reconstructed using a unified shape calculation; that is, the embedding column subgraph derived from the symbolic expression is replaced with a unified operator for simplification, resulting in a new reconstructed embedding column subgraph. Redundancy removal and embedding lookup simplification can be performed on the reconstructed embedding column subgraph to obtain a simplified embedding column subgraph. All simplified embedding column subgraphs in the embedding layer can be fused to obtain a fused operator. For example, a parallelism-oriented fusion method can be used to fuse the embedding column subgraphs.

[0165] Optionally, after mapping the embedded column to the corresponding processor, the processor can perform calculation operations on the embedded column according to the computing resources required by the embedded column, determine the calculation result corresponding to the embedded column, and then update the recommendation model according to the calculation result.

[0166] Optionally, by performing simplification operations on each embedding column and performing corresponding calculation operations on the processed embedding columns, the corresponding calculation results can be obtained. The calculation results can be used to update the original deep recommendation model. For example, kernel functions or operators corresponding to the embedding columns can be added to the corresponding positions in the original deep recommendation model to update the deep recommendation model.

[0167] Through steps S502 to S508 of this application, a computational process describing the original recommendation model is obtained. The original recommendation model is used to determine service information to be recommended to the target object. Running the original recommendation model requires computational resources to complete the computational process. Different computational sub-processes are simplified, with the simplified sub-processes requiring fewer computational resources than the unsimplified sub-processes. The simplified sub-processes are mapped to corresponding computational units to obtain a set of computational units. The computational units contained in the set are fused, and a target recommendation model corresponding to the original recommendation model is generated based on the fusion result. Different computational sub-processes of the target recommendation model require matching computational resources to generate service information, thereby improving data processing efficiency and solving the problem of low data processing efficiency.

[0168] Example 2

[0169] According to an embodiment of this application, an embodiment of a data processing system is also provided. Figure 6 This is a schematic diagram of a data processing system according to an embodiment of this application, such as... Figure 6 As shown, the data processing system 600 may include: a client 601, a cloud server 602, and a computing terminal 603.

[0170] Client 601 is used to detect model processing requests on the interactive interface. These model processing requests are used to request the cloud server to process the original model.

[0171] In this embodiment, the client 601 can detect the model processing request generated by the user performing a corresponding request operation on the interactive interface of the terminal device. The model processing request can be used to request the cloud server to process the original model to obtain the target model. The terminal device can be a mobile phone, personal computer (PC), or tablet computer, etc., of the target object; this is merely an example and not a specific limitation.

[0172] Optionally, if the user needs to process the original model, they can perform corresponding input operations such as clicking on the interactive interface to generate corresponding model processing instructions. Based on these instructions, a corresponding model processing request can be sent to the cloud server 602 to process the original model.

[0173] Cloud server 602 is used to respond to model processing requests, obtain a computational flow describing the original model, wherein running the original model requires computing resources to complete the computational flow; identify at least one computational sub-flow from the computational flow; simplify different computational sub-flows, wherein the simplified computational sub-flows require less computing resources than the original computational sub-flows; map the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fuse the computational units contained in the set of computational units, and generate a target model corresponding to the original model based on the fusion result.

[0174] In this embodiment, after detecting a model processing request, the cloud server 602 can obtain the computational flow describing the original model and identify the computational sub-flows from the computational flow. These sub-flows can then be simplified. After simplification, the simplified computational sub-flows can be mapped to corresponding computational units for fusion processing, thereby generating a target model corresponding to the original model.

[0175] Optionally, by identifying the original model, a computational flow describing the computational resources required to run the original model can be determined. Computational sub-flows can be identified from this flow, and simplified based on the amount of computational resources required, resulting in simplified sub-flows with fewer computational resources. These sub-flows can be mapped to corresponding computational units for fusion processing, generating a fusion result. Based on the fusion result, a target model corresponding to the original model can be generated, thus achieving the goal of updating the original model based on the fusion result. The target model can then be sent to the computational terminal.

[0176] The computation terminal 603 is used to call computational resources that match different computational sub-processes of the target model, process the corresponding computational sub-processes, and obtain the computational results.

[0177] In this embodiment, after receiving the target model sent by the cloud server 602, the computing terminal 603 can call computing resources that match different computing sub-processes of the target model to process the corresponding computing sub-processes and determine the computing results.

[0178] The method described in this embodiment will be further described below.

[0179] As an optional implementation, the cloud server identifies the computation process, obtains at least one variable of the original model, and determines the computation sub-process based on the variable; and / or, the computing end is used to call the computation sub-process of the target model to use matching computing resources based on the processing type to be processed in the computation sub-process of the target model.

[0180] In this embodiment, the computation process can be identified via a cloud server, at least one variable in the original model can be identified, and computational sub-processes can be determined based on the variables. The computing end can then determine the matching computing resources required to invoke the computational sub-processes of the target model based on the processing type to be processed in the target model's computational sub-processes.

[0181] Optionally, the computation process can be broken down and identified to obtain at least one variable in the original model, and computational sub-processes in the computation process can be determined based on the variable. The variable can be used to represent trainable data in the original model that matches the type of the computational sub-process. The variable can be an embedded table variable or a trainable variable.

[0182] Optionally, the computation graph can be identified to obtain at least one embedding table of the original model, and embedding columns can be determined based on the embedding table, wherein the operation information corresponding to the embedding table can be associated with the embedding columns. The processing type corresponding to the computation sub-process of the target model can be determined, and according to the processing type, the computing resources and corresponding processors to be matched for the computation sub-process in the target model can be determined, wherein the processing type can be used to indicate the type of operation to be performed on the computation sub-process of the target model.

[0183] The processing type can be determined. When the processing type is a sub-process of calculation for the target model that needs to perform string operations, it is determined that computing resources in the central processing unit can be used. When the processing type is a sub-process of calculation for the target model that needs to perform non-string operations, it is determined that computing resources in the graphics processing unit (GPU) can be used. The GPU can also be called an image processor.

[0184] Optionally, based on the operation information of the embedded column, the embedded column can be mapped to the corresponding processor. The operation information can be used to characterize whether a string operation is performed on the embedded column, and may include information on operations such as Gather.

[0185] For example, if a string operation is performed on the embedded column, that embedded column can be mapped to the CPU. If no string operation is performed on the embedded column, it can be mapped to the GPU. It should be noted that this is merely an example and does not impose specific limitations on the operation information or the methods and processes by which operation information is mapped to the corresponding processor.

[0186] As an optional implementation, the computing end is used to send the calculation result to the client; the client is used to respond to the first modification operation applied to the interactive interface and modify the calculation result.

[0187] In this embodiment, the calculation result can be sent to the client via the computing terminal. When the client receives the calculation result, it can modify the calculation result accordingly based on whether the user has made a first modification operation on the calculation result in the client.

[0188] Optionally, the computing terminal can send the calculation results to the terminal device of the corresponding user on the client side. The user can determine whether to modify the calculation results based on their own needs and the accuracy of the calculation results. If so, the user can perform a first modification operation on the interactive interface of the terminal device and modify the calculation results accordingly based on the modification instructions of the first modification operation.

[0189] As an optional implementation, the cloud server is used to send the computation sub-process to the client; the client is used to respond to the second modification operation applied to the interactive interface, modify the computation sub-process, and send the modified computation sub-process to the cloud server.

[0190] In this embodiment, a cloud server can be used to send the computation sub-process to the client. When the client receives the computation sub-process, it can modify the computation sub-process accordingly based on the second modification operation performed by the user on the client to determine whether the computation sub-process needs to be modified.

[0191] Optionally, the cloud server can send the computation sub-process to the corresponding user's terminal device on the client. The user can determine whether to modify the computation sub-process based on their needs and the accuracy of the computation sub-process. If so, they can execute a second modification operation on the terminal device's interactive interface, modifying the computation sub-process accordingly based on the modification instructions provided in the second modification operation.

[0192] As an optional implementation, the computing terminal is used to send computing results to the client; the cloud server is used to send computing sub-processes to the client; and the client is used to respond to query operations on the interactive interface and display computing results and computing sub-processes on the interactive interface.

[0193] In this embodiment, the final calculation result can be sent to the client through the computing terminal, the final calculation sub-process can be sent to the client through the cloud server, and the client can detect whether there is a query operation on the terminal device. If a query operation is detected on the interactive interface, the calculation result and calculation sub-process are displayed on the interactive interface.

[0194] In this embodiment, a data processing system is provided. A client 601 is used to detect model processing requests on an interactive interface, wherein the model processing request requests a cloud server to process the original model. A cloud server 602 is used to respond to the model processing request by obtaining a computational flow describing the original model, wherein running the original model requires computing resources to complete the computational flow; identifying at least one computational sub-flow from the computational flow; simplifying different computational sub-flows, wherein the simplified computational sub-flows require less computing resources than the unsimplified computational sub-flows; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target model corresponding to the original model based on the fusion result; and a computing terminal 603 is used to call computing resources matching different computational sub-flows of the target model, process the corresponding computational sub-flows, and obtain computational results, thereby achieving the technical effect of improving data processing efficiency and solving the technical problem of low data processing efficiency.

[0195] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this application, such as the data to be verified, are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use and processing of the relevant data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and corresponding operation entry points are provided for users to choose to authorize or refuse.

[0196] Example 3

[0197] Currently, embedding columns are crucial for achieving high accuracy in deep recommendation models, but they are extremely time-consuming during inference. On one hand, manual tuning can be performed for different recommendation models. However, as models become more complex and numerous, manual tuning for all models gradually becomes impossible. On the other hand, machine learning compilers can automatically tune machine learning models, but existing work cannot solve the three performance problems caused by embedding columns in recommendation models. First, generating efficient GPU code for operators in a large number of embedding columns is difficult. Existing compilers lead to fragmented kernel execution and underutilization of subgraph parallelism. Second, complex shape calculations in dynamic shape scenarios hinder further computational graph-level tuning by the compiler. Third, machine learning frameworks inevitably introduce redundant computations for robustness considerations, resulting in significant performance overhead. Therefore, this invention proposes a machine learning compiler that automatically tunes a large number of embedding columns in recommendation models, effectively solving the above performance problems. However, the technical problem of low data processing efficiency still exists.

[0198] Optionally, this application provides a method for automatically adjusting a large number of embedded columns in a deep recommendation model. This method solves the technical problem of low data processing efficiency. Unlike traditional solutions that do not process a large number of embedded columns, this method avoids the technical problem of low data processing efficiency caused by manual adjustment and solves the technical problem of low data processing efficiency.

[0199] In this embodiment, the original model can be identified to determine the computational flow that requires computing resources to run it. Computational sub-flows can be identified from this flow, and simplified based on the amount of computing resources required, resulting in simplified sub-flows with fewer resources. These sub-flows can be mapped to corresponding computing units for fusion processing, generating a fusion result. The target model corresponding to the original model can be generated based on the fusion result, thus updating the original model. Since the original model contains numerous computational flows causing various problems, these issues can be avoided by focusing on the computational sub-flows and their required computing resources. This improves data processing efficiency and solves the problem of low data processing efficiency.

[0200] The method described in this embodiment will be further described below.

[0201] In this embodiment, Figure 7 This is a flowchart illustrating the compilation and adjustment of a large number of embedded columns in a deep recommendation model according to an embodiment of this application, such as... Figure 7 As shown, the method may include the following steps:

[0202] Step S701: Identify the embedded columns from the computation graph.

[0203] In the technical solution provided by step S701 of this application, after obtaining the computation graph of the model to be processed, the computation graph can be identified, and the embedded columns in the embedding layer can be determined.

[0204] Optionally, when there is a model with a deep neural network that needs to be processed by an embedding layer, the model can be identified as the model to be processed, and the deep neural network in the model to be processed can be spliced ​​with an embedding vector.

[0205] Figure 8 This is a flowchart illustrating the identification of embedded columns according to an embodiment of this application, such as... Figure 8 As shown, the method may include the following steps:

[0206] Step S801: Identify all embedded tables from the computation graph.

[0207] In the technical solution provided by step S801 of this application, all embedded table variables in the computation graph can be identified based on the type of operator applied after the trainable variables.

[0208] Step S802: For all nodes, count the embedded tables contained in the pioneer nodes.

[0209] In the technical solution provided by step S802 of this application, for all nodes, it is possible to count the number of embedded tables included in the direct or indirect pioneer nodes.

[0210] Step S803: Determine whether to traverse all embedded tables.

[0211] In the technical solution provided by step S803 of this application, all embedding tables in the model to be processed can be traversed, and it can be determined whether all embedding tables have been traversed. For each embedding table, step S804 can be executed. If the traversal has been completed, the process can end.

[0212] Step S804: Initialize the embedded column subgraph.

[0213] In the technical solution provided by step S804 of this application, the embedded column subgraph corresponding to the current embedded table can be initialized.

[0214] Step S805: Initialize the queue.

[0215] In the technical solution provided by step S805 of this application, a queue for breadth-first traversal can be initialized.

[0216] Step S806: Determine if the queue is not empty.

[0217] In the technical solution provided in step S806 of this application, it can be determined whether the queue is not empty. If the queue is not empty, step S807 can be executed. Otherwise, the process can jump to step S812.

[0218] Step S807: Dequeue the node from the queue.

[0219] In the technical solution provided by step S807 of this application, a node can be dequeued from the current queue.

[0220] Step S808: Determine whether to traverse all successor nodes.

[0221] In the technical solution provided in step S808 of this application, all successor nodes of a node can be traversed, and it can be determined whether all successor nodes have been traversed. For each successor node, step S809 can be executed. If all successor nodes have been traversed, the process can jump to step S806.

[0222] Step S809: Determine if the number of the node's precursor embedding table is ≤1.

[0223] In the technical solution provided in step S809 of this application, it can be determined whether the number of the precursor embedding table of the node is ≥1. If so, step S810 can be executed. If the number of the precursor embedding table is <1, the process can jump to step S808.

[0224] Step S810: Insert the node into the current embedded column subgraph.

[0225] In the technical solution provided by step S810 of this application, a node can be inserted into the current embedded column subgraph.

[0226] Step S811: Enqueue the node into the queue.

[0227] In the technical solution provided in step S811 of this application, the node can be enqueued into the queue and the process can jump to step S808.

[0228] Step S812: Determine whether to traverse all nodes.

[0229] In the technical solution provided in step S812 of this application, all nodes can be traversed, and it can be determined whether all nodes in the current embedded subgraph have been traversed. For each node, step S813 can be executed. If all nodes have been traversed, the process can jump to step S815.

[0230] Step S813: Determine whether to traverse all predecessor nodes.

[0231] In the technical solution provided in step S813 of this application, all predecessor nodes of the current node can be traversed, and it can be determined whether all predecessor nodes of the current node have been traversed. For each predecessor node, step S814 can be executed. If all predecessor nodes have been traversed, the process can jump to step S815.

[0232] Step S814: Insert the node into the current embedded column subgraph.

[0233] In the technical solution provided by step S814 of this application, nodes can be inserted into the currently embedded column subgraph.

[0234] Step S815: Should the embedded subgraph be updated?

[0235] In the technical solution provided in step S815 of this application, it can be determined whether the embedded subgraph has been updated in the current iteration. If so, the process can proceed to step S812. Otherwise, the process can proceed to step S803.

[0236] Step S702: Adjust the embedded column at the graph level.

[0237] In the technical solution provided by step S702 of this application, the embedded column can be adjusted on the layer surface.

[0238] The presence of numerous embedded columns in the model to be processed can lead to various problems, resulting in low data processing efficiency. In this embodiment, all embedded columns in the embedding layer can be identified from the computation graph of the model to be processed. These embedded columns can then be used to convert the features to be processed into computational subgraphs. This conversion process essentially involves adjusting the embedded column subgraph at the graph level, simplifying it. Therefore, by simplifying the embedded column subgraph, corresponding computational subgraphs are obtained. Furthermore, the simplified computational subgraphs corresponding to all embedded columns are merged, thereby achieving the goal of simplifying the embedded column subgraph and ultimately improving data processing efficiency.

[0239] Alternatively, the computation subgraph can be adjusted by analyzing the context in the embedded column to eliminate redundant computation information.

[0240] Optionally, adjustments can be made at the graph level of the embedded column, that is, the embedded column subgraph can be adjusted to simplify and adjust the embedded column subgraph.

[0241] Optionally, for each embedding column in the embedding layer, a symbolic expression for the shape of all tensors in the embedding column subgraph of the embedding column can be derived at the graph level. For example, Figure 7 Within the embedded subgraph, the symbolic expressions corresponding to all tensor computation nodes can be determined as follows: <n0> 、 <n1>,<n0,8> wait.

[0242] Optionally, the shape calculation subgraph containing all the shape calculation nodes in the embedded column subgraph can be determined. The shape calculation subgraph can be replaced by a unified operator, namely a unified shape construction node, thereby simplifying the embedded layer subgraph.

[0243] Alternatively, redundant security safeguards (data security information) in the embedded column can be removed.

[0244] Optionally, the embedded lookup portion of the embedded column subgraph can be simplified.

[0245] Step S703: Operator fusion between subgraphs.

[0246] In the technical solution provided by step S703 of this application, operator fusion can be performed between subgraphs.

[0247] Alternatively, all simplified embedding subgraphs in the embedding layer can be fused to obtain a fused operator. For example, a parallelism-oriented fusion method can be used to fuse the embedding subgraphs.

[0248] Optionally, the kernel function corresponding to the operator after the computation subgraph of all embedded columns is determined by CUDA, and the kernel function can be mapped to the processor.

[0249] In step S704, the CPU and GPU work together.

[0250] In the technical solution provided in step S704 of this application, after obtaining the kernel function, the embedded column can be analyzed to determine which processor the embedded column needs to perform computational operations on. For example, if the size of the embedded table contained in the embedded column reaches a certain threshold, the entire embedded column can be mapped to the CPU for processing. Based on the above-mentioned CPU and GPU co-operation mode, different embedded columns or operators corresponding to the embedded columns can be placed in suitable processors for computational operations according to actual needs, thereby reducing video memory overhead and achieving the goal of fully utilizing the computing resources in idle CPUs, thus realizing the technical effect of improving data processing efficiency.

[0251] Figure 9 This is a flowchart illustrating the joint operation of a CPU and a GPU according to an embodiment of this application, such as... Figure 9 As shown, the method may include the following steps:

[0252] Step S901: Place the DNN part on the GPU.

[0253] In the technical solution provided by step S901 of this application, the DNN part of the given model to be processed can be placed on the GPU.

[0254] Step S902: Determine whether to traverse all embedded columns.

[0255] In the technical solution provided by step S902 of this application, the embedded columns in the model to be processed can be traversed, and it can be determined whether all embedded columns have been traversed. For each embedded column, step S903 can be executed. If all embedded columns have been traversed, the process can jump to step S909.

[0256] Step S903: Determine whether the size of the embedded table has reached the threshold.

[0257] In the technical solution provided in step S903 of this application, it can be determined whether the size of the embedded table has reached the threshold. If so, the process can jump to step S908; otherwise, step S904 can be executed.

[0258] Step S904: Determine whether all operators in the embedded column have been traversed.

[0259] In the technical solution provided in step S904 of this application, all operators contained in the embedded column can be traversed, and it can be determined whether all operators have been traversed. For each operator, step S905 can be executed. If all operators have been traversed, the process can jump to step S902.

[0260] Step S905: Determine whether the operator belongs to string operations.

[0261] In the technical solution provided in step S905 of this application, it can be determined whether the current operator belongs to string operation. If so, step S906 can be executed. If it does not belong to string operation, step S907 can be executed.

[0262] Step S906: Place the operator on the CPU.

[0263] In the technical solution provided in step S906 of this application, operators belonging to string operations can be placed on the CPU. Then, proceed to step S904.

[0264] Step S907: Place the operator on the GPU.

[0265] In the technical solution provided in step S907 of this application, operators that are not part of string operations can be placed on the GPU. Then proceed to step S904.

[0266] Step S908: Place the embedded column onto the CPU.

[0267] In the technical solution provided in step S908 of this application, the entire embedded column can be placed on the GPU. Then proceed to step S902.

[0268] Step S909, merge the embedded columns on the GPU.

[0269] In the technical solution provided by step S909 of this application, all embedded column operators placed on the GPU can be merged into a kernel function.

[0270] Step S910: Merge CPU and GPU transmissions.

[0271] In the technical solution provided by step S910 of this application, the copy transfer between the CPU and the GPU can be merged.

[0272] In this embodiment, the computation graph of the model to be processed can be identified to determine the computational flow between the deep neural network and the embedding layer that describes the model, as well as the embedding columns in the embedding layer. A processor matching the computational resources required by the embedding column can be determined, and the identified embedding columns can be mapped to the corresponding processor. The processor can then perform computational operations on the embedding column according to the matching computational resources to obtain the corresponding computational result. Based on the computational result, the initial model to be processed can be updated. Since the large number of embedding columns in the model to be processed can solve many problems, the processor can perform computations on the embedding layer and its required computational resources, thus avoiding the problems caused by a large number of embedding columns. This achieves the technical effect of improving data processing efficiency and solves the technical problem of low data processing efficiency.

[0273] Example 4

[0274] According to embodiments of this application, a method for implementing the above is also provided. Figure 3 The data processing device for the data processing method shown.

[0275] Figure 10 This is a schematic diagram of a data processing apparatus according to an embodiment of this application, such as... Figure 10 As shown, the data processing device 1000 may include: a first acquisition unit 1002, a first identification unit 1004, a first simplification unit 1006, a first mapping unit 1008, and a first processing unit 1010.

[0276] The first acquisition unit 1002 is used to acquire the computational process describing the original model, wherein computing resources are required to complete the computational process when running the original model.

[0277] The first identification unit 1004 is used to identify at least one calculation sub-process from the calculation process.

[0278] The first simplification unit 1006 is used to simplify different calculation sub-processes, wherein the amount of computing resources required by the simplified calculation sub-process is less than the amount of computing resources required by the calculation sub-process before simplification.

[0279] The first mapping unit 1008 is used to map the simplified calculation sub-processes to the corresponding calculation units to obtain a set of calculation units.

[0280] The first processing unit 1010 is used to fuse the computing units contained in the computing unit set and generate a target model corresponding to the original model based on the fusion result. Different computing sub-processes of the target model need to be processed using matching computing resources.

[0281] Here, the first acquisition unit 1002, the first identification unit 1004, the first simplification unit 1006, the first mapping unit 1008, and the first processing unit 1010 correspond to steps S302 to S310 in Embodiment 1. The five units and their corresponding steps implement the same instances and application scenarios, but are not limited to the content disclosed in Embodiment 1. It should be noted that the above units can be hardware or software components stored in a memory or database on a cloud server and processed by one or more processors. These units can also run as part of a device on a cloud server.

[0282] According to embodiments of this application, a method for implementing the above is also provided. Figure 4 The data processing device for the data processing method shown.

[0283] Figure 11 This is a schematic diagram of a data processing apparatus according to an embodiment of this application, such as... Figure 11 As shown, the data processing device 1100 may include: a first calling unit 1102, a second identification unit 1104, a second simplification unit 1106, a second mapping unit 1108, a second processing unit 1110, and a second calling unit 1112.

[0284] The first calling unit 1102 is used to obtain the calculation process describing the original model by calling the first interface. The first interface includes a first parameter, the value of which is the calculation process. When running the original model, computing resources are required to complete the calculation process.

[0285] The second identification unit 1104 is used to identify at least one calculation sub-process from the calculation process.

[0286] The second simplification unit 1106 is used to simplify different calculation sub-processes, wherein the amount of computing resources required by the simplified calculation sub-process is less than the amount of computing resources required by the calculation sub-process before simplification.

[0287] The second mapping unit 1108 is used to map the simplified calculation sub-processes to the corresponding calculation units to obtain a set of calculation units.

[0288] The second processing unit 1110 is used to fuse the computing units contained in the computing unit set and generate a target model corresponding to the original model based on the fusion result. Different computing sub-processes of the target model need to be processed using matching computing resources.

[0289] The second calling unit 1112 is used to output the target model by calling the second interface, wherein the second interface includes a second parameter, and the parameter value of the second parameter is the target model.

[0290] It should be noted that the first calling unit 1102, the second identification unit 1104, the second simplification unit 1106, the second mapping unit 1108, the second processing unit 1110, and the second calling unit 1112 mentioned above correspond to steps S402 to S412 in Embodiment 1. The six units and the corresponding steps implement the same instances and application scenarios, but are not limited to the content disclosed in Embodiment 1. It should be noted that the above units can be hardware or software components stored in a memory or database in a cloud server and processed by one or more processors. The above units can also run in a cloud server as part of a device.

[0291] According to embodiments of this application, a method for implementing the above is also provided. Figure 5 The information recommendation method shown is an information recommendation device.

[0292] Figure 12 This is a schematic diagram of an information recommendation device according to an embodiment of this application, such as... Figure 12 As shown, the information recommendation device 1200 may include: a second acquisition unit 1202, a third simplification unit 1204, a third mapping unit 1206, and a third processing unit 1208.

[0293] The second acquisition unit 1202 is used to acquire the computational process describing the original recommendation model, wherein the original recommendation model is used to determine the service information to be recommended to the target object, and computing resources are required to complete the computational process when running the original recommendation model.

[0294] The third simplification unit 1204 is used to simplify different calculation sub-processes, wherein the amount of computing resources required by the simplified calculation sub-process is less than the amount of computing resources required by the calculation sub-process before simplification.

[0295] The third mapping unit 1206 is used to map the simplified computation sub-processes to the corresponding computation units to obtain a set of computation units.

[0296] The third processing unit 1208 is used to fuse the computing units contained in the computing unit set and generate a target recommendation model corresponding to the original recommendation model based on the fusion result. The different computing sub-processes of the target recommendation model need to be processed using matching computing resources to generate service information.

[0297] It should be noted that the second acquisition unit 1202, the third simplification unit 1204, the third mapping unit 1206, and the third processing unit 1208 mentioned above correspond to steps S502 to S508 in Embodiment 1. The four units and their corresponding steps implement the same instances and application scenarios, but are not limited to the content disclosed in Embodiment 1. It should also be noted that the aforementioned units can be hardware or software components stored in a memory or database on a cloud server and processed by one or more processors. These units can also run on a cloud server as part of a device.

[0298] In this data processing device, the original model can be identified to determine the computational flow that requires computing resources to run it. Sub-processes can be identified within this flow, and simplified based on the amount of computing resources required, resulting in sub-processes with fewer resources. These sub-processes can then be mapped to corresponding computing units for fusion processing, generating a fusion result. Based on the fusion result, a target model corresponding to the original model can be generated, thus updating the original model. Since the original model contains numerous computational processes, many problems arise. By focusing on the computational sub-processes and their required resources, redundant computations introduced by numerous processes can be avoided, preventing performance degradation. This improves data processing efficiency and solves the problem of low data processing efficiency.

[0299] Example 5

[0300] Embodiments of this application may provide a computer terminal, which may be any computer terminal device in a group of computer terminals. Optionally, in this embodiment, the aforementioned computer terminal may also be replaced by a mobile terminal or other terminal device.

[0301] Optionally, in this embodiment, the computer terminal may be located in at least one of a plurality of network devices in a computer network.

[0302] In this embodiment, the aforementioned computer terminal can acquire relevant operations of the target object, such as historical behavior information generated by user clicks in application software on the computer terminal. The cloud server can receive the historical behavior information from the computer terminal and store it in a database on the cloud server. The cloud server can execute the following steps of the data processing method: acquiring a computational flow describing the original model, wherein computing resources are required to complete the computational flow when running the original model; identifying at least one computational sub-flow from the computational flow; simplifying different computational sub-flows, wherein the simplified computational sub-flow requires less computing resources than the unsimplified computational sub-flow; mapping the simplified computational sub-flow to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target model corresponding to the original model based on the fusion result, wherein different computational sub-flows of the target model require matching computing resources for processing.

[0303] Optionally, after updating the original model, the target model can be used to infer the historical behavior information of the target object in the database of the cloud server to obtain the final service information that matches the target object, and then returned to the computer terminal of the target object to recommend service information to the target object.

[0304] Optionally, Figure 13 This is a structural block diagram of a computer terminal according to an embodiment of this application. Figure 13 As shown, the computer terminal A may include one or more (only one is shown in the figure) processors 1302, memory 1304, and transmission devices 1306. The processors 1302 can process historical behavior information of the target object in the application software and transmit it to the transmission devices 1306. The memory 1304 can store the service information finally received that matches the target object. The transmission devices 1306 can transmit historical behavior information, etc., to a cloud server for processing, and can also receive service information recommended by the cloud server to the target object.

[0305] The cloud server can access information and applications stored in its own storage to perform the following steps: obtain a computational flow describing the original model, wherein running the original model requires computing resources to complete the computational flow; identify at least one computational sub-flow from the computational flow; simplify different computational sub-flows, wherein the simplified computational sub-flow requires less computing resources than the original computational sub-flow; map the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fuse the computational units contained in the set of computational units, and generate a target model corresponding to the original model based on the fusion result, wherein different computational sub-flows of the target model require matching computing resources for processing.

[0306] Optionally, the aforementioned cloud server may also execute program code that performs the following steps: identifying at least one computational sub-process from the computational process, including: decomposing the computational process to identify at least one variable of the original model, wherein the variable represents the trainable data in the original model and matches the type of the computational sub-process; and determining the computational sub-process based on the variable. The type of the computational sub-process can be an operator type.

[0307] Optionally, the cloud server may also execute program code that performs the following steps: determining a computational sub-process based on variables, including: determining the initial computational sub-process corresponding to the variables; and updating the computational sub-process to a computational sub-process using the predecessor computational nodes of the computational nodes in the initial computational sub-process.

[0308] Optionally, the cloud server may also execute program code that performs the following steps: determining the processing type corresponding to the computational sub-process of the target model, wherein the processing type is used to indicate the type of operation to be performed on the computational sub-process of the target model; and determining the matching computing resources required for the computational sub-process of the target model based on the processing type.

[0309] Optionally, the cloud server may also execute program code that performs the following steps: based on the processing type, determine the matching computing resources required for the computational sub-process of the target model, including: in response to a string operation to be performed in the computational sub-process of the target model, determining to call computing resources in the central processing unit; in response to a non-string operation to be performed in the computational sub-process of the target model, determining to call computing resources in the graphics processing unit.

[0310] Optionally, the cloud server may also execute program code that performs the following steps: in response to the data volume of the variable corresponding to the computational sub-process of the target model being greater than the data volume threshold, determines to call the computing resources in the central processing unit; in response to the data volume of the variable corresponding to the computational sub-process of the target model not being greater than the data volume threshold, determines to call the computing resources in the graphics processing unit.

[0311] Optionally, the cloud server may also execute program code that performs the following steps: simplifying different computational sub-processes, including: reconstructing the computational sub-processes based on the description information of tensors in the computational sub-processes to obtain target computational sub-processes, wherein the description information is used to describe the attributes of tensors, and the amount of computational resources required by the target computational sub-processes is less than the amount of computational resources required by the computational sub-processes.

[0312] Optionally, the cloud server may also execute program code that performs the following steps: mapping the simplified computational sub-process to the corresponding computational unit to obtain a set of computational units, including: mapping the target computational sub-process after removing redundant data information and / or simplifying data lookup information to the corresponding computational unit to obtain a set of computational units.

[0313] The cloud server can perform the following steps by calling information and applications stored in its own storage: obtaining a computational flow describing the original model by calling a first interface, wherein the first interface includes a first parameter whose value is the computational flow, and computational resources are required to complete the computational flow when running the original model; identifying at least one computational sub-flow from the computational flow; simplifying different computational sub-flows, wherein the simplified computational sub-flow requires less computational resources than the unsimplified computational sub-flow; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target model corresponding to the original model based on the fusion result, wherein different computational sub-flows of the target model require matching computational resources for processing; and outputting the target model by calling a second interface, wherein the second interface includes a second parameter whose value is the target model.

[0314] Cloud servers can execute the following steps by accessing information and applications stored in their own storage: obtaining a computational flow describing the original recommendation model, where the original recommendation model determines service information to be recommended to the target object, and running the original recommendation model requires computational resources to complete the computational flow; simplifying different computational sub-flows, where the simplified computational sub-flows require fewer computational resources than the original computational sub-flows; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target recommendation model corresponding to the original recommendation model based on the fusion result, where different computational sub-flows of the target recommendation model require matching computational resources to generate service information.

[0315] This application provides a data processing method. In this embodiment, the original model is identified to determine the computational flow that requires computing resources to run the original model. Computational sub-flows can be identified from the computational flow, and the computational flow can be simplified according to the amount of computing resources required, resulting in simplified computational sub-flows with fewer computing resources. These computational sub-flows can be mapped to corresponding computing units for fusion processing to generate a fusion result. Based on the fusion result, a target model corresponding to the original model can be generated, thereby achieving the purpose of updating the original model based on the fusion result. Since the original model contains numerous computational flows that cause many problems, by calculating the computational sub-flows and their required computing resources, the problem of redundant computation leading to reduced model performance caused by numerous computational flows can be avoided. This achieves the technical effect of improving data processing efficiency and solves the technical problem of low data processing efficiency.

[0316] Those skilled in the art will understand that Figure 13 The structure shown is for illustrative purposes only. Computer terminal A can also be a smartphone (such as an Android phone, iOS phone, etc.), tablet computer, handheld computer, mobile internet device (MID), PAD and other terminal devices. Figure 13 This does not limit the structure of the aforementioned computer terminal A. For example, computer terminal A may also include components that are more complex than those described above. Figure 13 The more or fewer components shown (such as network interfaces, display devices, etc.), or having the same Figure 13 The different configurations shown.

[0317] Those skilled in the art will understand that all or part of the steps in the various methods of the above embodiments can be implemented by a program instructing the hardware related to the terminal device. The program can be stored in a computer-readable storage medium, which may include: flash drive, read-only memory (ROM), random access memory (RAM), disk or optical disk, etc.

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

[0319] The program code used to implement the methods of this application may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing device, such that when executed by the processor or controller, the functions / operations specified in the flowcharts and / or block diagrams are implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

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

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

[0322] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with embodiments of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0323] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact via communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, servers in distributed systems, or servers incorporating blockchain technology.

[0324] It should be noted that the sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0325] In the above embodiments of this application, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0326] In the several embodiments provided in this application, it should be understood that the disclosed technical content can be implemented in other ways. The device embodiments described above are merely illustrative; for example, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection of units or modules may be electrical or other forms.

[0327] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0328] 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.

[0329] 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.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as a USB flash drive, read-only memory (ROM), random access memory (RAM), portable hard drive, magnetic disk, or optical disk.

[0330] The above are merely preferred embodiments of this application. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of this application, and these improvements and modifications should also be considered within the scope of protection of this application. < / n0> < / n0>

Claims

1. A data processing method, characterized in that, include: Obtain the computational flow used to describe the original model, wherein running the original model requires the use of computing resources to complete the computational flow; Identify at least one computational sub-process from the computational process, wherein the computational sub-process is an embedded column in the embedding layer of the original model; Different computational sub-processes are simplified, and the simplified computational sub-processes require less computational resources than the original computational sub-processes. The simplified computational sub-processes are mapped to the corresponding computational units to obtain a set of computational units; The computing units contained in the computing unit set are fused together, and a target model corresponding to the original model is generated based on the fusion result. Different computing sub-processes of the target model need to be processed using matching computing resources. The simplification of different calculation sub-processes includes: reconstructing the embedding column based on the description information of the tensor in the embedding column, wherein the description information is used to describe the attributes of the tensor; The simplified computational sub-processes are mapped to the corresponding computational units to obtain a set of computational units, including: mapping the kernel functions corresponding to the simplified embedded columns to the computational units to obtain the set of computational units.

2. The method according to claim 1, characterized in that, Identify at least one computational sub-process from the computational flow, including: The computation process is broken down to identify at least one variable of the original model, wherein the variable is used to represent the trainable data in the original model and matches the type of the computation sub-process; The calculation sub-process is determined based on the variables.

3. The method according to claim 2, characterized in that, The calculation sub-process is determined based on the variables, including: Determine the initial calculation subprocess corresponding to the variable; The initial calculation subprocess is updated to the calculation subprocess using the predecessor calculation node of the calculation node in the initial calculation subprocess.

4. The method according to claim 1, characterized in that, The method further includes: Determine the processing type corresponding to the computational sub-process of the target model, wherein the processing type is used to represent the type of operation to be performed on the computational sub-process of the target model; Based on the processing type, it is determined that the computational sub-processes of the target model require matching computational resources.

5. The method according to claim 4, characterized in that, Based on the processing type, the computational sub-processes of the target model require matching computational resources, including: In response to the processing type being a string operation to be performed in a computational sub-process of the target model, it is determined that computing resources in the central processing unit will be invoked; In response to the processing type being a non-string operation to be performed on a computational subprocess of the target model, it is determined that computational resources in the graphics processor should be invoked.

6. The method according to claim 1, characterized in that, The method further includes: If the amount of data for the variables corresponding to the computational sub-process of the target model is greater than the data amount threshold, it is determined to call the computing resources in the central processing unit. If the data volume of the variable corresponding to the calculation sub-process of the target model is not greater than the data volume threshold, it is determined to call the computing resources in the graphics processor.

7. The method according to any one of claims 1 to 6, characterized in that, The method further includes: The simplified calculation sub-process is determined as the target calculation sub-process, wherein the amount of computing resources required by the target calculation sub-process is less than the amount of computing resources required by the calculation sub-process.

8. The method according to claim 7, characterized in that, The method further includes: Remove redundant data information from the target computation sub-process, wherein the redundant data information is used to at least characterize the data security performance of the target computation sub-process; and / or, Simplify the data lookup information in the target calculation sub-process, wherein the data lookup information is used to find the data embedded in the target calculation sub-process.

9. The method according to claim 8, characterized in that, The simplified computational sub-processes are mapped to corresponding computational units to obtain a set of computational units, including: The target calculation sub-process, after removing redundant data information and / or simplifying data lookup information, is mapped to the corresponding calculation unit to obtain the calculation unit set.

10. A data processing method, characterized in that, include: The computational process describing the original model is obtained by calling a first interface, wherein the first interface includes a first parameter, the value of which is the computational process, and computational resources are required to complete the computational process when running the original model. Identify at least one computational sub-process from the computational process, wherein the computational sub-process is an embedded column in the embedding layer of the original model; Different computational sub-processes are simplified, and the simplified computational sub-processes require less computational resources than the original computational sub-processes. The simplified computational sub-processes are mapped to the corresponding computational units to obtain a set of computational units; The computing units contained in the computing unit set are fused together, and a target model corresponding to the original model is generated based on the fusion result. Different computing sub-processes of the target model need to be processed using matching computing resources. The target model is output by calling the second interface, wherein the second interface includes a second parameter, and the parameter value of the second parameter is the target model; The simplification of different calculation sub-processes includes: reconstructing the embedding column based on the description information of the tensor in the embedding column, wherein the description information is used to describe the attributes of the tensor; The simplified computational sub-processes are mapped to the corresponding computational units to obtain a set of computational units, including: mapping the kernel functions corresponding to the simplified embedded columns to the computational units to obtain the set of computational units.

11. An information recommendation method, characterized in that, Applied to compilers, including: Obtain the computational process used to describe the original recommendation model, wherein the original recommendation model is used to determine the service information to be recommended to the target object, and the computational process requires computing resources to run the original recommendation model; Different computational sub-processes are simplified, wherein the simplified computational sub-processes require less computational resources than the original computational sub-processes. The computational sub-processes are the embedded columns in the embedding layer of the original recommendation model. The simplified computational sub-processes are mapped to the corresponding computational units to obtain a set of computational units; The computing units contained in the computing unit set are fused together, and a target recommendation model corresponding to the original recommendation model is generated based on the fusion result. The different computing sub-processes of the target recommendation model need to be processed using matching computing resources to generate the service information. The simplification of different calculation sub-processes includes: reconstructing the embedding column based on the description information of the tensor in the embedding column, wherein the description information is used to describe the attributes of the tensor; The simplified computational sub-processes are mapped to the corresponding computational units to obtain a set of computational units, including: mapping the kernel functions corresponding to the simplified embedded columns to the computational units to obtain the set of computational units.

12. A data processing system, characterized in that, include: A client is used to detect model processing requests on the interactive interface, wherein the model processing requests are used to request the cloud server to process the original model; A cloud server is configured to respond to the model processing request by obtaining a computational flow describing the original model, wherein running the original model requires computing resources to complete the computational flow; identifying at least one computational sub-flow from the computational flow, wherein the computational sub-flow is an embedded column in the embedding layer of the original model; simplifying different computational sub-flows, wherein the simplified computational sub-flow requires less computing resources than the unsimplified computational sub-flow; mapping the simplified computational sub-flows to corresponding computational units to obtain a set of computational units; fusing the computational units contained in the set of computational units, and generating a target model corresponding to the original model based on the fusion result; The computing end is used to call computing resources that match different computing sub-processes of the target model, process the corresponding computing sub-processes, and obtain computing results; The cloud server is used to simplify different computational sub-processes by performing the following steps: reconstructing the embedding column based on the description information of the tensor in the embedding column, wherein the description information is used to describe the attributes of the tensor; The cloud server is used to obtain the set of computing units by performing the following steps: mapping the kernel functions corresponding to the simplified embedded columns to the computing units to obtain the set of computing units.

13. The system according to claim 12, characterized in that, The cloud server identifies the computation process, obtains at least one variable of the original model, and determines the computation sub-process based on the variable. And / or, The computing terminal is used to call the matching computing resources required by the computing sub-process of the target model based on the processing type to be processed in the computing sub-process of the target model.

14. The system according to claim 12, characterized in that, The computing terminal is used to send the computing result to the client; The client is configured to respond to a first modification operation applied to the interactive interface and modify the calculation result.

15. The system according to claim 12, characterized in that, The cloud server is used to send the computation sub-process to the client; The client is configured to respond to a second modification operation applied to the interactive interface, modify the computation sub-process, and send the modified computation sub-process to the cloud server.

16. The system according to claim 12, characterized in that, The computing terminal is used to send the computing result to the client; The cloud server is used to send the computation sub-process to the client; The client is used to respond to query operations performed on the interactive interface and to display the calculation results and the calculation sub-process on the interactive interface.

17. An electronic device, characterized in that, include: Memory and processor; The memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions, which, when executed by the processor, implement the steps of the method according to any one of claims 1 to 11.

Images