Graph data storage, access, processing method, training method, device and medium

Abstract

The disclosure provides a kind of graph data storage, access, processing method, training method, equipment and medium, it is related to artificial intelligence technical field, especially it is related to graph neural network technology, computer vision and deep learning technical field.The specific implementation scheme is: in response to receiving graph data storage request, the division is carried out to the graph data to be stored, obtains at least two graph slice data to be stored;According to at least two graph slice data to be stored, obtain target graph slice data and associated graph slice data;The target graph slice data is stored to graphics processing unit (GPU);Associated graph slice data is stored to internal memory;At least two graph slice data to be stored is stored to external memory.

Description

[0001] This application is a divisional application of the application filed on May 19, 2022, with application number 202210573156.3, entitled "Graph Data Storage, Access, Processing Method, Training Method, Apparatus and Medium". Technical Field

[0002] This disclosure relates to the field of artificial intelligence technology, and more particularly to the fields of graph neural network technology, computer vision, and deep learning technology. Specifically, it relates to a graph data storage, access, processing method, training method, device, and medium. Background Technology

[0003] With the continuous development of computer technology, graph data has also evolved. Graph data can be used to represent node and edge information using graph theory. Graph data is widely used in fields such as knowledge graphs, financial fraud detection, and social relationship mining. Summary of the Invention

[0004] This disclosure provides a graph data storage, access, processing method, training method, device, and medium.

[0005] According to one aspect of this disclosure, a graph data storage method is provided, comprising: in response to receiving a graph data storage request, dividing the graph data to be stored to obtain at least two graph tile data to be stored; obtaining target graph tile data and associated graph tile data based on the at least two graph tile data to be stored; storing the target graph tile data in a graphics processing unit (GPU); storing the associated graph tile data in internal memory; and storing the at least two graph tile data to be stored in external memory.

[0006] According to another aspect of this disclosure, a graph data access method is provided, comprising: in response to receiving a graph data access request, obtaining an identifier to be accessed; and, if it is determined that there is a matching identifier in the target graph slice data that matches the identifier to be accessed, obtaining an access result from the target graph slice data according to the matching identifier, wherein the target graph slice data is graph data to be stored in a graphics processing unit (GPU) according to the method described above.

[0007] According to another aspect of this disclosure, a graph data access method is provided, comprising: in response to receiving an access identifier from a graphics processing unit (GPU), and if it is determined that a matching identifier exists in associated graph tile data that matches the access identifier, obtaining an access result from the associated graph tile data based on the matching identifier, wherein the associated graph tile data is graph data to be stored in the internal memory according to the method described above; and sending the access result to the GPU.

[0008] According to another aspect of this disclosure, a method for training a graph neural network model is provided, comprising: in response to receiving a model training request, determining at least one target sampling node from target graph slice data based on a sampling strategy, wherein the target graph slice data is data to be stored in a graphics processing unit (GPU) according to the method described above; obtaining at least one first-order neighbor node corresponding to the at least one target sampling node from one of the target graph slice data, associated graph slice data, and at least two graph slice data to be stored, wherein the associated graph slice data is graph data to be stored in internal memory according to the method described above, and the at least two graph slice data to be stored are graph data to be stored in external memory according to the method described above; obtaining at least one-order subgraph data based on the target sampling node related data of the at least one target sampling node and the neighbor node related data of the at least one first-order neighbor node; and sending the at least one-order subgraph data to a deep learning platform so that the deep learning platform can train the graph neural network model using the at least one-order subgraph data.

[0009] According to another aspect of this disclosure, a graph data processing method is provided, comprising: inputting target graph data into a graph neural network model to obtain an output result, wherein the graph neural network model is trained using the method described above according to this disclosure.

[0010] According to another aspect of this disclosure, a graph data storage device is provided, comprising: a first obtaining module, configured to, in response to receiving a graph data storage request, divide the graph data to be stored to obtain at least two graph tile data to be stored; a second obtaining module, configured to obtain target graph tile data and associated graph tile data based on the at least two graph tile data to be stored; a first storage module, configured to store the target graph tile data in a graphics processing unit (GPU); a second storage module, configured to store the associated graph tile data in an internal memory; and a third storage module, configured to store the at least two graph tile data to be stored in an external memory.

[0011] According to another aspect of this disclosure, a graph data access apparatus is provided, comprising: a first acquisition module, configured to acquire an identifier to be accessed in response to receiving a graph data access request; and a second acquisition module, configured to, if it is determined that a matching identifier exists in the target graph tile data that matches the identifier to be accessed, acquire an access result from the target graph tile data based on the matching identifier, wherein the target graph tile data is graph data to be stored in the graphics processing unit (GPU) of the apparatus described above according to this disclosure.

[0012] According to another aspect of this disclosure, a graph data access apparatus is provided, comprising: a third acquisition module, configured to, in response to receiving an access identifier from a graphics processing unit (GPU), acquire an access result from the associated graph tile data based on the matching identifier if it is determined that a matching identifier exists in the associated graph tile data that matches the access identifier, wherein the associated graph tile data is graph data to be stored in the internal memory of the apparatus described in this disclosure; and a second transmission module, configured to transmit the access result to the GPU.

[0013] According to another aspect of this disclosure, a training apparatus for a graph neural network model is provided, comprising:

[0014] The device comprises a determining module, configured to, in response to receiving a model training request, determine at least one target sampling node from target graph slice data based on a sampling strategy, wherein the target graph slice data is data to be stored in the graphics processing unit (GPU) of the device described herein; a fourth obtaining module, configured to, based on the at least one target sampling node, obtain at least one first-order neighbor node corresponding to the at least one target sampling node from the target graph slice data, associated graph slice data, and at least two graph slice data to be stored, wherein the associated graph slice data is graph data to be stored in the internal memory of the device described herein, and the at least two graph slice data to be stored are graph data to be stored in the external memory of the device described herein; a third obtaining module, configured to obtain at least one-order subgraph data based on the target sampling node related data of the at least one target sampling node and the neighbor node related data of the at least one first-order neighbor node; and a fifth sending module, configured to send the at least one-order subgraph data to a deep learning platform so that the deep learning platform can train the graph neural network model using the at least one-order subgraph data.

[0015] According to another aspect of this disclosure, a graph data processing apparatus is provided, comprising: inputting target graph data into a graph neural network model and obtaining an output result, wherein the graph neural network model is trained using the apparatus described above according to this disclosure.

[0016] According to another aspect of this disclosure, an electronic device is provided, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the method described in this disclosure.

[0017] According to another aspect of this disclosure, a non-transitory computer-readable storage medium is provided storing computer instructions, wherein the computer instructions are used to cause the computer to perform the methods described in this disclosure.

[0018] According to another aspect of this disclosure, a computer program product is provided, including a computer program that, when executed by a processor, implements the methods described in this disclosure.

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

[0020] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein:

[0021] Figure 1 The illustration schematically shows an exemplary system architecture for applying graph data storage methods, graph data access methods, graph neural network model training methods, and graph data processing methods and apparatus according to embodiments of the present disclosure;

[0022] Figure 2 A flowchart illustrating a graph data storage method according to an embodiment of the present disclosure is shown schematically.

[0023] Figure 3 This illustration schematically shows an example diagram of a graph data storage process according to an embodiment of the present disclosure;

[0024] Figure 4 A flowchart illustrating a graph data access method according to an embodiment of the present disclosure is shown schematically.

[0025] Figure 5 A flowchart illustrating a graph data access method according to another embodiment of the present disclosure is shown schematically;

[0026] Figure 6 A flowchart illustrating a training method for a graph neural network model according to an embodiment of the present disclosure is shown schematically.

[0027] Figure 7 The diagram illustrates an example of the training process of a graph neural network model according to an embodiment of the present disclosure.

[0028] Figure 8 A flowchart illustrating a graph data processing method according to an embodiment of the present disclosure is shown schematically; and

[0029] Figure 9 A block diagram of a graph data storage device according to an embodiment of the present disclosure is shown schematically;

[0030] Figure 10 A block diagram of a graph data access apparatus according to an embodiment of the present disclosure is shown schematically;

[0031] Figure 11 A block diagram of a graph data access apparatus according to another embodiment of the present disclosure is shown schematically;

[0032] Figure 12 A block diagram of a training apparatus for a graph neural network model according to an embodiment of the present disclosure is shown schematically.

[0033] Figure 13 A block diagram of a graph data processing apparatus according to an embodiment of the present disclosure is schematically shown; and

[0034] Figure 14 The diagram illustrates a block diagram of an electronic device suitable for implementing a graph data storage method, a graph data access method, a graph neural network model training method, and a graph data processing method according to embodiments of the present disclosure. Detailed Implementation

[0035] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0036] Figure 1 The illustration schematically depicts an exemplary system architecture for applying graph data storage methods, graph data access methods, graph neural network model training methods, and graph data processing methods and apparatus according to embodiments of the present disclosure.

[0037] It is important to note that Figure 1 The examples shown are merely examples of system architectures that can be applied to the embodiments of this disclosure, in order to help those skilled in the art understand the technical content of this disclosure, but do not mean that the embodiments of this disclosure cannot be used in other devices, systems, environments or scenarios.

[0038] like Figure 1 As shown, the system architecture 100 according to this embodiment may include a graph engine 101, a deep learning platform 102, and a network 103. The network 103 serves as a medium for providing a communication link between the graph engine 101 and the deep learning platform 102. The network 103 may include various connection types, such as wired and / or wireless communication links.

[0039] The storage structure of the graphics engine 101 may include a GPU (Graphics Processing Unit) 101_1, internal memory 102_2, and external memory 102_3. Internal memory 102_1 may include CPU (Central Processing Unit) memory. External memory 101_3 may include at least one of the following: hard disk, floppy disk, optical disk, and USB flash drive. The hard disk may include at least one of the following: solid-state drive (SSD) and hard disk drive (HDD).

[0040] Graph engine 101 can be used to respond to a received graph data storage request by partitioning the graph data to be stored to obtain at least two graph slice data to be stored. Based on the at least two graph slice data to be stored, target graph slice data and associated graph slice data are obtained. The target graph slice data is stored in GPU 101_1. The associated graph slice data is stored in internal memory 101_2. The at least two graph slice data to be stored are stored in external memory 101_3.

[0041] GPU101_1 in graph engine 101 can respond to a received graph data access request by obtaining the identifier to be accessed. If it is determined that there is a matching identifier in the target graph tile data that matches the identifier to be accessed, the access result is obtained from the target graph tile data based on the matching identifier.

[0042] The internal memory 101_2 in the graph engine 101 can, in response to receiving a pending access identifier from the GPU 101_1, and if it determines that a matching identifier exists in the associated graph tile data that matches the pending access identifier, retrieve the access result from the associated graph tile data based on the matching identifier, and send the access result to the GPU 101_1.

[0043] In response to receiving a model training request, graph engine 101 determines at least one target sampling node from the target graph tile data based on a sampling strategy. Based on the at least one target sampling node, it obtains at least one first-order neighbor node corresponding to the at least one target sampling node from the target graph tile data, associated graph tile data, and one of at least two graph tile data to be stored. Based on the target sampling node-related data of the at least one target sampling node and the neighbor node-related data of the at least one first-order neighbor node, it obtains at least one-order subgraph data. It then sends the at least one-order subgraph data to deep learning platform 102 so that deep learning platform 102 can train a graph neural network model using the at least one-order subgraph data.

[0044] The deep learning platform 102 can train a graph neural network model using at least one-order subgraph data received from the graph engine 101.

[0045] The graph engine 101 can be a server or a terminal device. The deep learning platform 102 can be a server, a server cluster, or a terminal device. Various communication client applications can be installed on the terminal device, such as knowledge reading applications, web browser applications, search applications, instant messaging tools, email clients, and / or social media platform software (for example only). The terminal device can be various electronic devices with a display screen that support web browsing, including but not limited to smartphones, tablets, laptops, and desktop computers.

[0046] A server can be any type of server that provides various services. For example, a server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product in the cloud computing service system. It solves the problems of high management difficulty and weak business scalability in traditional physical hosts and VPS (Virtual Private Server) services. A server can also be a server for a distributed system, or a server that incorporates blockchain technology.

[0047] It should be understood that Figure 1 The number of graph engines, deep learning platforms, and networks shown is merely illustrative. Depending on the implementation requirements, any number of graph engines, deep learning platforms, and networks can be used.

[0048] It should be noted that the sequence numbers of the operations in the following methods are for descriptive purposes only and should not be considered as indicating the execution order of the operations. Unless explicitly stated otherwise, the method does not need to be executed in the exact order shown.

[0049] Figure 2 A flowchart illustrating a graph data storage method according to an embodiment of the present disclosure is shown schematically.

[0050] like Figure 2 As shown, the method 200 includes operations S210 to S250.

[0051] In operation S210, in response to receiving a graph data storage request, the graph data to be stored is divided to obtain at least two graph slice data to be stored.

[0052] In operation S220, target map tile data and associated map tile data are obtained based on at least two map tile data to be stored.

[0053] During operation of S230, the target image slice data is stored to the GPU.

[0054] In operation S240, the associated graph slice data is stored in the internal memory.

[0055] In operation S250, at least two plot data to be stored are stored to external memory.

[0056] According to embodiments of this disclosure, a graph data storage request can refer to a request for storing data to be stored. Graph data can refer to data characterized by node data and edge data. Node data can include at least one node label for a node and at least one node attribute corresponding to the node label. Edge data can include edge labels for edges and at least one edge attribute corresponding to the edge labels. Edge labels can be used to characterize the relationship between two nodes connected by the edge. They can be used to characterize entities. Edges can be used to characterize the relationship between two connected nodes. Nodes can be characterized using node identifiers. Edges can be characterized using edge identifiers. Furthermore, edge data associated with a node can be used as the node's dependency data. The node's dependency data can be used as the node's node feature data. Thus, graph data can include node data and node feature data.

[0057] According to embodiments of this disclosure, a node may have neighboring nodes corresponding to that node. The number of neighboring nodes may include one or more. A neighboring node may refer to a node that has a relationship with the node. Neighboring nodes may have a hierarchical relationship. For example, a neighboring node directly determined based on a node may be identified as a first-order neighboring node of that node. A neighboring node determined based on a first-order neighboring node of that node may be identified as a second-order neighboring node of that node. And so on, a node may have at least one first-order neighboring node corresponding to that node.

[0058] According to embodiments of this disclosure, the graph data to be stored may refer to graph data to be stored. The graph data to be stored may have the same data structure as the graph data.

[0059] According to embodiments of this disclosure, graph tile data can refer to graph data obtained by partitioning graph data. For example, graph partitioning algorithms can be used to partition graph data to obtain at least two graph tile data. Graph partitioning algorithms can include one of the following: node-based graph partitioning algorithms and edge-based graph partitioning algorithms. Edge-based graph partitioning algorithms can refer to graph partitioning algorithms that partition graph data according to edges. Node-based graph partitioning algorithms can refer to graph data partitioning algorithms that partition data according to nodes. The implementation of a graph partitioning algorithm needs to satisfy one of the following three conditions: First, the partitioned nodes should be as related as possible (i.e., the number of edges in the partitioned graph tile data to be stored should be as large as possible, and the number of edges across tiles should be as small as possible). Second, the amount of data in each graph tile data to be stored should be as equal as possible. Third, the weights of each node should be as equal as possible. Each graph tile data to be stored has a sum of node weights corresponding to that graph tile data. The sum of node weights can be determined based on the node weights of each node included in the graph tile data to be stored. The node weights of a node can be determined based on whether the node has labeled data. For example, if a node has labeled data, its weight can be set to a number greater than and less than 1. If the node does not have labeled data, its weight can be set to 0. The method for setting node weights can be configured according to actual business needs and is not limited here. The reason why the weights of each node should be as equal as possible is that if all the target nodes in a target graph tile obtained based on the graph partitioning algorithm are nodes without labeled data, and subsequent sampling is performed using a conditional sampling strategy that determines target nodes with labeled data as target sampling nodes, then none of the target nodes in the target graph tile will meet the condition and cannot become target sampling nodes. As a result, the target graph tile data is not utilized, reducing data utilization efficiency.

[0060] According to embodiments of this disclosure, the graph slice data to be stored can refer to graph data obtained by partitioning the graph data to be stored. The target graph slice data can be graph slice data to be stored that meets predetermined conditions. The associated graph slice data can be graph data to be stored obtained based on the target graph slice data. The predetermined conditions can be configured according to actual business needs and are not limited herein.

[0061] According to embodiments of this disclosure, the relationship between target graph tile data and associated graph tile data can include one of the following: the target graph tile data may have no intersection with the associated graph tile data, and the target graph tile data may have intersection with the associated graph tile data. When the target graph tile data may have no intersection with the associated graph tile data, the associated graph tile data can be referred to as complementary graph tile data of the target graph tile data. The intersection between the target graph tile data and the associated graph tile data can include at least one of the following: the associated graph tile data includes all the target graph tile data, and the associated graph tile data includes a portion of the target graph data.

[0062] According to embodiments of this disclosure, obtaining target graph tile data and associated graph tile data based on at least two graph tile data to be stored may include: obtaining target graph tile data based on at least two graph tile data to be stored; determining associated graph tile data from at least one other graph tile data to be stored based on the target graph tile data; and determining associated graph tile data from at least one other graph tile data to be stored based on the target graph tile data. The other graph tile data to be stored may refer to any one of the at least two graph tile data to be stored other than the target graph tile data. Determining associated graph tile data from at least one other graph tile data to be stored based on the target graph tile data may include: extracting at least a predetermined number of other graph tile data to be stored from at least one other graph tile data to be stored based on the target graph tile data to obtain associated graph tile data.

[0063] According to embodiments of this disclosure, after obtaining the target graph tile data and associated graph tile data, the target graph tile data can be stored in the GPU. The associated graph tile data can be stored in internal memory. At least two graph tile data to be stored can be stored in external memory.

[0064] According to embodiments of this disclosure, target image tile data is stored in a graphics processing unit (GPU), associated image tile data is stored in internal memory, and at least two image tile data to be stored are stored in external memory, thereby realizing a three-level storage system based on a single machine, reducing communication overhead, and expanding the storage capacity of a single machine.

[0065] According to embodiments of this disclosure, operation S210 may include the following operations.

[0066] In response to receiving a graph data storage request, a node-based graph partitioning algorithm divides the graph data to be stored, resulting in at least two graph slices to be stored.

[0067] According to embodiments of this disclosure, node data and neighbor node data can be determined from graph data to be stored using a node-based graph partitioning algorithm. Based on the node data and neighbor node data, at least two graph slices to be stored are obtained.

[0068] According to embodiments of this disclosure, operation S220 may include the following operations.

[0069] Determine the target graph tile data from at least two graph tile data sets to be stored. Based on the target graph tile data, determine the associated graph tile data from the graph data sets to be stored.

[0070] According to embodiments of this disclosure, target graph slice data can be determined from at least two graph slice data to be stored based on a predetermined determination strategy. The predetermined determination strategy may include a random determination strategy, i.e., randomly determining the target graph slice data from at least two graph slice data to be stored. According to embodiments of this disclosure, after determining the target graph slice data, a target predetermined node corresponding to the first predetermined node can be determined from other graph data to be stored based on the degree of association between a first predetermined node in the target graph slice data and a second predetermined node in other graph data to be stored. The degree of association between the first predetermined node and the second predetermined node can be determined based on at least one of the out-degree and in-degree of the first predetermined node. Based on the target predetermined node corresponding to the first predetermined node, associated graph slice data corresponding to the target graph slice data is obtained. The degree of association between the second predetermined node and the first predetermined node can be determined based on the number of edges between the second predetermined node and the first predetermined node. For example, the number of edges between the second predetermined node and the first predetermined node is greater than or equal to a predetermined edge number threshold. The predetermined edge number threshold can be configured according to actual business needs and is not limited here.

[0071] According to embodiments of this disclosure, the GPU can be at least one GPU card.

[0072] According to embodiments of this disclosure, operation S230 may include the following operations.

[0073] The target image slice data is divided into at least one target image partition. The at least one target image partition data is then stored in at least one GPU card.

[0074] According to embodiments of this disclosure, the target graph slice data may include target node data and target node feature data of at least one target node. Target nodes can be characterized using target node identifiers. The target graph slice data can be divided based on the target node identifiers of the target nodes to obtain at least one target graph partition (i.e., partition) data. For example, at least one target node identifier can be processed to obtain at least one target node identifier processed value. The target node data of the target node identifier corresponding to the same target node identifier processed value is determined as the target graph partition data. Thus, the target node data in each target graph partition data is the target node data of the target node corresponding to the same target node identifier processed value.

[0075] According to embodiments of this disclosure, at least one target graph partition data can be stored on at least one GPU card based on the association between the GPU card and the target node identifier processing value. Each GPU card can be used to store the target graph partition data corresponding to that GPU card.

[0076] For example, it can include N GPU cards, namely GPU card 1, GPU card 2, ..., GPU card n GPU card N -1 and GPU card N It can include N target map partition data, namely target map partition data 1, target map partition data 2, ..., target map partition data n ... target map partition data N-1 And target map partition data N With GPU card n The corresponding target node identifier processing value is f(n). This is related to the target graph partition data. n The corresponding target node identifier processing value is f(n). N can be an integer greater than or equal to 1. n∈{1,2,...,(N-1),N}.

[0077] According to embodiments of this disclosure, dividing the target map slice data to obtain at least one target map partition data may include the following operations.

[0078] The target graph slice data is divided based on the first hash algorithm to obtain at least one target graph partition data.

[0079] According to embodiments of this disclosure, a hash algorithm can be used to process node identifiers to obtain a node identifier processing value. This node identifier processing value obtained by processing the node identifier using a hash algorithm can be called a hash value.

[0080] According to embodiments of this disclosure, a first hash algorithm can be used to process the target node identifiers used to represent target nodes in the target graph partitioning data to obtain at least one first hash value. The target node data corresponding to the target node identifier with the same first hash value is determined as the target graph partitioning data.

[0081] According to embodiments of this disclosure, the internal memory may include at least one internal storage region.

[0082] According to embodiments of this disclosure, storing associated graph tile data in internal memory may include the following operations.

[0083] The association graph slice data is divided to obtain at least one association graph partition data. The at least one association graph partition data is stored in at least one internal storage area.

[0084] According to embodiments of this disclosure, each internal storage area can be used to store association graph partition data corresponding to that internal storage area. According to embodiments of this disclosure, the association graph slice data can include association node data and association node feature data of at least one associated node. Associated nodes can be characterized using association node identifiers. The association graph slice data can be divided according to the association node identifiers of the associated nodes to obtain at least one association graph partition data. For example, at least one association node identifier can be processed to obtain at least one association node identifier processing value. The association node data of the association node identifier corresponding to the same association node identifier processing value is determined as the association graph partition data. Thus, the association node data in each association graph partition data is the association node data of the associated node corresponding to the same association node identifier processing value.

[0085] According to embodiments of this disclosure, dividing the association graph slice data to obtain at least one association graph partition data may include the following operations.

[0086] The association graph slice data is divided based on the second hash algorithm to obtain at least one association graph partition data.

[0087] According to embodiments of this disclosure, a second hash algorithm can be used to process the association node identifiers used to represent association nodes in the association graph partitioning data to obtain at least one second hash value. The association node data with association node identifiers corresponding to the same second hash value is determined as the association graph partitioning data.

[0088] According to embodiments of this disclosure, the above-described graph data storage method may further include the following operations.

[0089] In response to a detected storage switch command, based on at least two graph tile data sets to be stored, new target graph tile data and new associated graph tile data are obtained. The target graph tile data stored in the GPU is deleted. The associated graph tile data stored in internal memory is deleted. The new target graph tile data is stored in the GPU. The new associated graph tile data is stored in internal memory.

[0090] According to embodiments of this disclosure, a storage switching instruction can refer to re-determining the target graph tile data stored in the GPU and the associated graph tile data stored in internal memory. The storage switching instruction may be generated in response to receiving a training completion instruction from the deep learning platform.

[0091] According to embodiments of this disclosure, upon detecting a memory switching instruction, target image slice data stored in the GPU can be deleted. Associated image slice data stored in internal memory can also be deleted. New target image slice data and new associated image slice data can be obtained from at least two image slice data to be stored using the method described above. The new target image slice data is stored in the GPU. The new associated image slice data is stored in internal memory.

[0092] According to embodiments of this disclosure, the relationship between target graph tile data and associated graph tile data may include one of the following: there is no intersection between target graph tile data and associated graph tile data, and associated graph tile data may include target graph tile data.

[0093] According to embodiments of this disclosure, the target graph tile data may include at least one of the following: node-related data and neighbor node-related data.

[0094] According to embodiments of this disclosure, node-related data may include at least one of the following: node data and node feature data.

[0095] According to embodiments of this disclosure, neighbor node-related data may include at least one of the following: neighbor node data and neighbor node feature data.

[0096] According to embodiments of this disclosure, the associated graph tile data may include at least one of the following: associated node related data and associated neighbor node related data.

[0097] According to embodiments of this disclosure, the associated node-related data may include at least one of the following: associated node data and associated node feature data.

[0098] According to embodiments of this disclosure, the associated neighbor node related data may include at least one of the following: associated neighbor node data and associated neighbor node feature data.

[0099] According to embodiments of this disclosure, node feature data of a node may be determined based on edge data associated with the node.

[0100] According to embodiments of this disclosure, node data and node feature data of a node are stored together on the same storage device. For example, target node data of target node A is stored on the GPU, target node feature data of target node A is also stored on the GPU, and target node data and target node feature data of target node A can be stored on the same GPU card.

[0101] According to embodiments of this disclosure, since node feature data and node data are stored together on the same storage device, the efficiency of subsequent data access can be improved.

[0102] The following is for reference. Figure 3 The graph data storage method according to the embodiments of this disclosure will be further described in conjunction with specific examples.

[0103] Figure 3 The illustration shows an example schematic diagram of a graph data storage process according to an embodiment of the present disclosure.

[0104] like Figure 3 As shown, in 300, the graph engine may include GPU memory 301, CPU internal memory 302, and external memory 303. GPU memory 301 may include T GPU cards, namely GPU card 301_1, GPU card 301_2, ..., GPU card 301_t, ..., GPU card 301_(T-1), and GPU card 301_T. T is an integer greater than 1. t is an integer greater than or equal to 1 and less than T.

[0105] The internal memory may include S internal storage regions. These S internal storage regions may include internal storage region 302_1, internal storage region 302_2, ..., internal storage region 302_s, ..., internal storage region 302_(S-1), and internal storage region 302_S. S is an integer greater than 1. s is an integer greater than or equal to 1 and less than S.

[0106] The graph data to be stored can be divided into R slice data, namely slice data 304_1, slice data 304_2, ..., slice data 304_r, ..., slice data 304_(R-1) and slice data 304_R. R is an integer greater than 1. r is an integer greater than or equal to 1 and less than R.

[0107] From the R plot data to be stored, plot data 304_2 can be identified as the target plot data. Based on the target plot data, the associated plot data can be determined from the plot data to be stored.

[0108] The target image slice data can be divided into T target image partition data, namely target image partition data 304_2_1, target image partition data 304_2_2, ..., target image partition data 304_2_t, ..., target image partition data 304_2_(T-1) and target image partition data 304_2_T. The target image partition data 304_2_t is then stored in GPU card 301_t.

[0109] The slice data of the correlation graph can be divided into S correlation graph partition data, namely correlation graph partition data 305_1, correlation graph partition data 305_2, ..., correlation graph partition data 305_s, ..., correlation graph partition data 305_(S-1) and correlation graph partition data 305_S. The target graph partition data 305_s is stored in the internal storage area 302_s.

[0110] The R map slice data to be stored are stored in external memory 303.

[0111] Figure 4 A flowchart illustrating a graph data access method according to an embodiment of the present disclosure is shown schematically.

[0112] like Figure 4 As shown, the method 400 includes operations S410 to S420.

[0113] In operation S410, in response to receiving a graph data access request, the identifier to be accessed is obtained.

[0114] In operation S420, if it is determined that there is a matching identifier in the target map tile data that matches the identifier to be accessed, the access result is obtained from the target map tile data according to the matching identifier.

[0115] According to embodiments of this disclosure, the target graph slice data may be the graph data to be stored in the GPU in the graph data storage method described in embodiments of this disclosure.

[0116] According to embodiments of this disclosure, a graph data access request can refer to a request for accessing graph data to be stored. Access can include at least one of the following: adding, deleting, modifying, querying, and sampling. The identifier to be accessed can include the identifier of the node to be accessed. The matching identifier can include the identifier of the matching node.

[0117] According to embodiments of this disclosure, after obtaining the identifier to be accessed, the GPU can determine whether a matching identifier exists in the target graph slice data that matches the identifier to be accessed. If a matching identifier exists in the target graph slice data, the graph data corresponding to the matching identifier can be obtained from the target graph slice data, and the graph data corresponding to the matching identifier can be determined as the access result. For example, the GPU can determine whether a matching identifier exists in the target graph slice data that matches the identifier to be accessed. If a matching identifier exists in the target graph slice data, the graph data corresponding to the matching identifier can be obtained from the target graph slice data, and the graph data corresponding to the matching identifier can be determined as the access result. The identifier to be accessed can be an identifier of a node to be accessed. The matching identifier can be an identifier of a matching node.

[0118] According to embodiments of this disclosure, access results can be obtained from the GPU, improving access speed and reducing communication overhead.

[0119] According to embodiments of this disclosure, the GPU may include at least one GPU card.

[0120] According to embodiments of this disclosure, operation S420 may include the following operations.

[0121] If a matching identifier exists in the current target graph partition data that matches the identifier to be accessed, the access result is obtained from the target graph slice data based on the matching identifier. If no matching identifier exists in the current target graph partition data, the GPU card corresponding to the identifier to be accessed is determined. The identifier to be accessed is sent to the GPU card corresponding to the identifier to be accessed, so that if a matching identifier exists in the target graph partition data of the GPU card corresponding to the identifier to be accessed, the GPU card can obtain the access result from the target graph slice data based on the matching identifier. The system responds to receiving the access result from the GPU card corresponding to the identifier to be accessed.

[0122] According to embodiments of this disclosure, the GPU card that receives the graph data access request can be referred to as the current GPU card. The target graph partition data stored in the current GPU card is referred to as the current target graph partition data.

[0123] According to embodiments of this disclosure, the current GPU card determines whether a matching identifier exists in the current target graph partition data that matches the identifier to be accessed. If the current GPU card determines that a matching identifier exists in the current target graph partition data, it can obtain the access result from the current target graph slice data based on the matching identifier.

[0124] According to embodiments of this disclosure, if the current GPU card determines that there is no matching identifier in the current target graph partition data that matches the identifier to be accessed, it can determine the GPU card corresponding to the identifier to be accessed based on the identifier to be accessed. The GPU card corresponding to the identifier to be accessed may include at least one. The current GPU card can send the identifier to be accessed to the GPU card corresponding to the identifier to be accessed. The GPU card corresponding to the identifier to be accessed can determine whether there is a matching identifier in the target graph partition data of the GPU card corresponding to the identifier to be accessed. If the GPU card corresponding to the identifier to be accessed determines that there is a matching identifier in the GPU card corresponding to the identifier to be accessed, it can obtain an access result from the target graph segmentation data corresponding to the identifier to be accessed based on the matching identifier. The GPU card corresponding to the identifier to be accessed can send the access result to the current GPU card.

[0125] According to embodiments of this disclosure, the above-described graph data access method may further include the following operations.

[0126] If no matching identifier exists in the target graph partition data of the GPU card corresponding to the identifier to be accessed, the identifier to be accessed is sent to internal memory. If internal memory then determines that a matching identifier exists in the associated graph slice data, it retrieves the access result from the associated graph slice data based on the matching identifier. This is in response to receiving the access result from the GPU card corresponding to the identifier to be accessed.

[0127] According to embodiments of this disclosure, the associated graph tile data can be graph data to be stored in the internal memory in the graph data storage method described in embodiments of this disclosure.

[0128] According to embodiments of this disclosure, if the GPU card corresponding to the identifier to be accessed determines that there is no matching identifier in the GPU card corresponding to the identifier to be accessed, the GPU card corresponding to the identifier to be accessed may send the identifier to be accessed to the internal memory. The internal memory may determine whether there is a matching identifier in the associated graph slice data that matches the identifier to be accessed. If the internal memory determines that there is a matching identifier in the associated graph slice data that matches the identifier to be accessed, it may obtain an access result from the associated graph slice data based on the matching identifier. The internal memory may send the access result to the GPU card corresponding to the identifier to be accessed. The GPU card corresponding to the identifier to be accessed may send the access result to the current GPU card.

[0129] According to embodiments of this disclosure, if the internal memory determines that there is no matching identifier in the associated graph tile data that matches the identifier to be accessed, it can send the identifier to be accessed to the external memory. This allows the external memory to retrieve access results from at least two graph tile data sets to be stored based on the identifier. The external memory can send the access results to the internal memory. The internal memory can send the access results to the GPU card corresponding to the identifier to be accessed. The GPU card corresponding to the identifier to be accessed can send the access results to the current GPU card.

[0130] According to embodiments of this disclosure, multiple GPU cards can be used to query and sample data from any target graph partition. The query and sampling functions of multiple GPU cards support high concurrency. A GPU card can simultaneously send requests to other GPU cards. Furthermore, the concurrency of GPUs is extremely high; the sampling speed of a GPU can be more than 400 times that of internal memory.

[0131] According to embodiments of this disclosure, the above-described graph data access method may further include the following operations.

[0132] Create a first access task based on the access identifier. Add the first access task to the first task queue corresponding to the GPU.

[0133] According to embodiments of this disclosure, operation S420 may include the following operations.

[0134] The first head task is retrieved from the GPU's task queue using the thread corresponding to the GPU. If the first head task is determined to be the first access task, the access identifier is retrieved from the first head task using the thread corresponding to the GPU. If a matching identifier exists in the target graph tile data that matches the access identifier, the access result is retrieved from the target graph tile data based on the matching identifier.

[0135] According to embodiments of this disclosure, the thread corresponding to the GPU can execute the first access task in the form of a task queue. The thread corresponding to the GPU can access the first task queue corresponding to the GPU and obtain the first head task in the first task queue. If the thread corresponding to the GPU determines that the first head task is the first access task, the thread corresponding to the GPU can execute the first access task.

[0136] According to embodiments of this disclosure, the above-described graph data access method may further include the following operations.

[0137] Once the thread corresponding to the GPU has determined that the first access task has been completed, the first access task is removed from the first task queue.

[0138] Figure 5 A flowchart illustrating a graph data access method according to another embodiment of the present disclosure is shown schematically.

[0139] like Figure 5 The method 500 includes operations S510 to S520.

[0140] In operation S510, in response to receiving a target identifier from the graphics processor (GPU), if it is determined that there is a matching identifier in the associated graph tile data that matches the target identifier, the access result is obtained from the associated graph tile data based on the matching identifier.

[0141] The S520 is used to send access results to the GPU.

[0142] According to embodiments of this disclosure, the associated graph tile data can be graph data to be stored in the internal memory in the graph data storage method described in embodiments of this disclosure.

[0143] According to embodiments of this disclosure, the above-described graph data storage method may further include the following operations.

[0144] If no matching identifier is found in the associated graph tile data, the identifier to be accessed is sent to external memory so that external memory can retrieve the access result from at least two graph tile data to be stored. In response to receiving the access result from external memory, the access result is sent to the GPU.

[0145] According to embodiments of this disclosure, at least two plot data to be stored can be data to be stored in the plot data storage method described in embodiments of this disclosure.

[0146] According to embodiments of this disclosure, operation S510 may include the following operations.

[0147] In response to receiving an access identifier from the GPU, a second access task is created based on the access identifier. The second access task is added to the second task queue corresponding to internal memory. A second head task is retrieved from the second task queue using the thread corresponding to internal memory. If the thread corresponding to internal memory determines that the second head task is the second access task, it retrieves the access identifier from the second head task. If the thread corresponding to internal memory determines that a matching identifier exists in the association graph slice data that matches the access identifier, it retrieves the access result from the association graph slice data based on the matching identifier.

[0148] According to embodiments of this disclosure, the thread corresponding to the internal memory can execute the second access task in the form of a task queue. The thread corresponding to the internal memory can access the second task queue corresponding to the internal memory and retrieve the second head task from the second task queue. If the thread corresponding to the internal memory determines that the second head task is the second access task, it can execute the second access task.

[0149] According to embodiments of this disclosure, the internal memory may include at least one internal storage region. Association graph partition data may be stored in the internal storage region. There may be threads corresponding to the internal storage region. There may be a second task queue corresponding to the internal storage region.

[0150] According to embodiments of this disclosure, the task queue design eliminates the need to concern developers with consistency issues arising from thread concurrency during subsequent strategy development, allowing them to focus on data processing logic. Furthermore, it avoids developers having to perform locking and unlocking operations when manipulating data, which increases system latency, thereby improving efficiency, reducing development costs, and decreasing the probability of errors.

[0151] According to embodiments of this disclosure, the above-described graph data access method may further include the following operations.

[0152] Once the thread corresponding to the internal memory has determined that the second access task has been completed, the second access task is removed from the second task queue.

[0153] Figure 6 A flowchart illustrating a training method for a graph neural network model according to an embodiment of the present disclosure is shown schematically.

[0154] like Figure 6 As shown, the method 600 includes operations S610 to S640.

[0155] In operation S610, in response to receiving a model training request, at least one target sampling node is determined from the target map slice data based on the sampling strategy.

[0156] In operation S620, based on at least one target sampling node, at least one first-order neighbor node corresponding to the at least one target sampling node is obtained from the target graph tile data, associated graph tile data, and at least one of the at least two graph tile data to be stored.

[0157] In operation S630, at least one-order subgraph data is obtained based on the target sampling node related data of at least one target sampling node and the neighbor node related data of at least one first-order neighbor node.

[0158] In operation S640, at least one-order subgraph data is sent to the deep learning platform so that the deep learning platform can use the at least one-order subgraph data to train a graph neural network model.

[0159] According to embodiments of this disclosure, the target graph tile data may be data to be stored in the GPU in the graph data storage method described in embodiments of this disclosure. The associated graph tile data may be graph data to be stored in internal memory in the graph data storage method described in embodiments of this disclosure. At least two graph tile data to be stored may be graph data to be stored in external memory in the graph data storage method described in embodiments of this disclosure.

[0160] According to embodiments of this disclosure, the graph neural network model may include one of the following: a graph convolutional network (GCN) model, a graph recurrent network (GRN) model, a graph attention network (GAT) model, and a graph residual network model. The graph neural network model can be used to generate node vectors for nodes.

[0161] According to embodiments of this disclosure, a model training request may refer to a request for training a graph neural network model. The model training request may be a response from the graph engine to receiving a model training request from a client. Alternatively, the model training request may be generated by the graph engine in response to detecting a model training operation involving object input.

[0162] According to embodiments of this disclosure, a sampling strategy can refer to a strategy used to determine sampling nodes. A sampling strategy can include one of the following: a traversal sampling strategy and a conditional sampling strategy.

[0163] According to embodiments of this disclosure, the graph data to be stored can be determined as sample graph data for training a graph neural network model. The graph data to be stored can be stored according to the graph data storage method described in embodiments of this disclosure.

[0164] According to embodiments of this disclosure, at least one target sampling node can be determined from target graph slice data based on a sampling strategy. For each target sampling node, at least one first-order neighbor node corresponding to the target sampling node is determined. For example, based on the target sampling node, it can be determined whether a first-order neighbor node corresponding to the target sampling node exists in the target graph slice data stored in the GPU. If it is determined that a first-order neighbor node corresponding to the target sampling node exists in the target graph slice data stored in the GPU, the first-order neighbor node corresponding to the target sampling node is obtained from the target graph slice data stored in the GPU. If it is determined that no first-order neighbor node corresponding to the target sampling node exists in the target graph slice data stored in the GPU, it can be determined whether a first-order neighbor node corresponding to the target sampling node exists in the associated graph slice data stored in internal memory. If it is determined that a first-order neighbor node corresponding to the target sampling node exists in the associated graph slice data stored in internal memory, the first-order neighbor node corresponding to the target sampling node is obtained from the associated graph slice data stored in internal memory. If it is determined that there is no first-order neighbor node corresponding to the target sampling node in the associated graph tile data stored in internal memory, the first-order neighbor node corresponding to the target sampling node is obtained from at least two graph tile data to be stored in external memory. Thus, at least one first-order neighbor node corresponding to the target sampling node can be obtained.

[0165] According to embodiments of this disclosure, for at least one first-order neighbor node among the first-order neighbor nodes of the target sampling node, at least one neighbor node corresponding to the first-order neighbor node can be determined using a method similar to that described above. The neighbor node corresponding to the first-order neighbor node can be referred to as the second-order neighbor node of the target sampling node. And so on, neighbor nodes of a predetermined order corresponding to the target sampling node can be obtained. The predetermined order can be configured according to actual business needs and is not limited herein. For example, the predetermined order can be third order.

[0166] According to embodiments of this disclosure, the sampling method for neighbor nodes described above involves first searching in the GPU; if no neighbor node is found in the GPU, then searching in internal memory; and if no neighbor node is found in internal memory, then searching in external memory. Furthermore, the sampling method can be configured according to actual business needs. For example, neighbor nodes can be searched in the GPU; if no neighbor node is found in the GPU, neither internal nor external memory is accessed. Alternatively, the search can be conducted in the GPU; if no neighbor node is found in the GPU, then a search can be conducted in internal memory; and if no neighbor node is found in internal memory, then external memory is not accessed.

[0167] According to embodiments of this disclosure, for a target sampling node among at least one target sampling node, at least one first-order subgraph data corresponding to the target sampling node can be obtained based on the target sampling node related data of the target sampling node and the neighbor node sampling related data of the at least one first-order neighbor nodes corresponding to the target sampling node. Thus, at least one first-order subgraph data corresponding to each of the at least one target sampling node can be obtained.

[0168] According to embodiments of this disclosure, a graph engine can send at least one-order subgraph data corresponding to at least one target sampling node to a deep learning platform. The deep learning platform can then use the at least one-order subgraph data to train a graph neural network model.

[0169] According to embodiments of this disclosure, taking sampling as an example, since the graph partitioning algorithm ensures a high degree of correlation between points within the graph slice data to be stored, there is a relatively high probability of obtaining first-order neighbor nodes from the GPU when performing first-order neighbor sampling on the GPU. When sampling second-order neighbor nodes based on first-order neighbor nodes, the sampling operation is more likely to occur on the GPU. Only when no neighbor nodes exist in the GPU will a query request be initiated to the internal and external memory. Since the GPU has the fastest access speed, followed by the internal memory, it is possible to ensure that access operations occur more frequently on the GPU and internal memory, thereby improving data processing efficiency. Furthermore, user-configurable sampling strategies can be supported.

[0170] According to embodiments of this disclosure, training of graph neural network models is performed based on graph data storage schemes and graph data access schemes, thereby improving the training speed of the models.

[0171] According to embodiments of this disclosure, the training method for the above-described graph neural network model may further include the following operations.

[0172] In response to receiving a training completion instruction from the deep learning platform, a storage switching instruction is generated. In response to detecting the storage switching instruction, and having obtained new target graph slice data and new associated graph slice data based on at least two graph slice data to be stored, the process of obtaining at least one-order subgraph data and sending at least one-order subgraph data to the deep learning platform, so that the deep learning platform can train a graph neural network model using the at least one-order subgraph data, is repeated until a predetermined number of graph slice data to be stored from the at least two graph slice data to be stored are determined to be target graph slice data, at which point the training operation of training the graph neural network model using the target graph slice data is completed.

[0173] According to embodiments of this disclosure, after training a graph neural network model using target graph tile data, new target graph tile data and new associated graph tile data can be obtained based on at least two graph tile data to be stored.

[0174] According to embodiments of this disclosure, the following operations can be repeated until a predetermined termination condition is met. Based on a sampling strategy, at least one new target sampling node is determined from new target graph tile data. Based on the at least one new target sampling node, at least one new first-order neighbor node corresponding to the at least one new target sampling node is obtained from the new target graph tile data, new associated graph tile data, and one of at least two graph tile data to be stored. Based on the target sampling node related data of the at least one new target sampling node and the neighbor node related data of the at least one new first-order neighbor node, at least one new first-order subgraph data is obtained. The at least one new first-order subgraph data is sent to a deep learning platform so that the deep learning platform can train a graph neural network model using the at least one new first-order subgraph data.

[0175] According to embodiments of this disclosure, a predetermined termination condition may refer to the completion of the training operation of training a graph neural network model using the target graph tile data when a predetermined number of the at least two graph tile data to be stored are determined to be the target graph tile data.

[0176] According to embodiments of this disclosure, a round of sampling can be initiated on target sampling points in the target graph slice data based on a sampling strategy. The sampled at least one-order subgraph data is then sent to a deep learning platform so that the platform can train a graph neural network model using the at least one-order subgraph data. This completes one round of model training. The above operation can lead to bias in the subgraph data, meaning that most of the subgraph data consists of neighboring nodes of the target sampling node. To address this, new target graph slice data can be periodically stored in the GPU and new associated graph slice data can be stored in internal memory, ensuring that each target node has a chance to become a target sampling point, thereby reducing bias. Furthermore, the system can maintain relatively high sampling performance.

[0177] According to embodiments of this disclosure, operation S610 may include one of the following operations.

[0178] In response to receiving a model training request, all target nodes in the target map slice data are identified as target sampling nodes based on the traversal sampling strategy.

[0179] In response to receiving a model training request, based on a conditional sampling strategy, a subset of target nodes in the target map slice data are identified as at least one target sampling node.

[0180] According to embodiments of this disclosure, a conditional sampling strategy can refer to a strategy that determines target nodes that meet predetermined sampling conditions as target sampling nodes. For example, the predetermined sampling condition can refer to the target sampling node being a target node with annotation information. Alternatively, the predetermined sampling condition can refer to the number of target sampling nodes being equal to a predetermined sampling number threshold.

[0181] The following is for reference. Figure 7 The training method of the graph neural network model according to the embodiments of this disclosure will be further explained in conjunction with specific embodiments.

[0182] Figure 7 The diagram illustrates an example of the training process of a graph neural network model according to an embodiment of the present disclosure.

[0183] like Figure 7 As shown, in module 700, the graph engine may include graph engine module 1, graph engine module 2, and graph engine module 3. Graph engine module 1 may include a GPU. The GPU may include four GPU cards. In addition, graph engine module 1 may include a multi-card sampling unit and a convergence unit. Graph engine module 2 may include an associative graph tile data generation unit. Graph engine module 3 may include a graph partitioning unit. Graph engine modules 2 and 3 periodically run user-configured node-based graph partitioning algorithms or system-integrated node-based graph partitioning algorithms.

[0184] The graph partitioning unit in Graph Engine Module 3 can divide the graph data to be stored based on a graph partitioning algorithm, obtaining at least two graph slices to be stored. It can then partition the target graph slice data (i.e., ...) from the at least two graph slices to be stored. Figure 7 In Graph Engine Module 2, the light-colored target node-related data and target neighbor node-related data are sent to the GPU in Graph Engine Module 1. Graph Engine Module 2, based on a graph partitioning algorithm, obtains associated graph tile data (i.e., ...) based on the target graph tile data and at least two graph data to be stored. Figure 7(The dark-colored associated node data and associated neighbor node data in Graph Engine Module 2). After Graph Engine Module 2 sends the target graph tile data to Graph Engine Module 1, Graph Engine Module 2 deletes the target graph tile data stored in Graph Engine Module 2. Graph Engine Module 2 ultimately retains the associated graph tile data.

[0185] Graph engine module 1 divides the target graph tile data into four target graph partitions. These four partitions are then stored on four GPUs. The target graph tile data stored on each GPU is distinct from the others.

[0186] In response to a sampling request received from the client, the multi-card sampling unit in Graph Engine Module 1 can sample from the data of the four target graph partitions to obtain at least one-order subgraph data. The aggregation unit in Graph Engine Module 1 aggregates the at least one-order subgraph data. The aggregation unit sends the at least one-order subgraph data to the client. The client then sends the at least one-order subgraph data to the deep learning platform.

[0187] Deep learning platforms train graph neural network models using at least first-order subgraph data. Node vectors can be obtained from the graph neural network model. These node vectors are associated with node identifiers.

[0188] Figure 8 A flowchart illustrating a graph data processing method according to an embodiment of the present disclosure is shown schematically.

[0189] like Figure 8 As shown, the method 800 includes operation S810.

[0190] When operating the S810, the target graph data is input into the graph neural network model to obtain the output result.

[0191] According to embodiments of this disclosure, the graph neural network model can be trained using the training method for the graph neural network model described in embodiments of this disclosure.

[0192] According to embodiments of this disclosure, graph neural network models have been explored in a wide range of problem domains, including supervised, semi-supervised, unsupervised, and reinforcement learning settings. Graph neural network models can be applied to various domains, such as recommendation systems.

[0193] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in the technical solution disclosed herein comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0194] The above are merely exemplary embodiments, but are not limited thereto. Other graph data storage methods, graph data access methods, graph neural network model training methods, and graph data processing methods known in the art may also be included, as long as they can reduce communication overhead and expand single-machine storage capacity.

[0195] Figure 9 A block diagram of a graph data storage device according to an embodiment of the present disclosure is shown schematically.

[0196] like Figure 9 As shown, the data storage device 900 may include a first acquisition module 910, a second acquisition module 920, a first storage module 930, a second storage module 940, and a third storage module 950.

[0197] The first obtaining module 910 is used to respond to receiving a graph data storage request by dividing the graph data to be stored and obtaining at least two graph slice data to be stored.

[0198] The second obtaining module 920 is used to obtain target map tile data and associated map tile data based on at least two map tile data to be stored.

[0199] The first storage module 930 is used to store the target image slice data to the GPU.

[0200] The second storage module 940 is used to store the associated graph slice data to the internal memory.

[0201] The third storage module 950 is used to store at least two map slice data to an external memory.

[0202] According to embodiments of this disclosure, the second obtaining module 920 may include a first determining submodule and a second determining submodule.

[0203] The first determination submodule is used to determine the target map tile data from at least two map tile data to be stored.

[0204] The second determination submodule is used to determine the associated map tile data from the map data to be stored based on the target map tile data.

[0205] According to embodiments of this disclosure, the GPU includes at least one GPU card.

[0206] According to embodiments of this disclosure, the first storage module 930 may include a first acquisition submodule and a first storage submodule.

[0207] The first acquisition submodule is used to divide the target map slice data to obtain at least one target map partition data.

[0208] The first storage submodule is used to store at least one target graph partition data to at least one GPU card.

[0209] According to embodiments of this disclosure, the first obtaining submodule may include a first obtaining unit.

[0210] The first obtaining unit is used to divide the target map slice data based on the first hash algorithm to obtain at least one target map partition data.

[0211] According to embodiments of this disclosure, the internal memory includes at least one internal storage region.

[0212] According to embodiments of this disclosure, the second storage module 940 may include a second acquisition submodule and a second storage submodule.

[0213] The second submodule is used to divide the association graph slice data to obtain at least one association graph partition data.

[0214] The second storage submodule is used to store at least one association graph partition data to at least one internal storage area.

[0215] According to embodiments of this disclosure, the second obtaining submodule may include a second obtaining unit.

[0216] The second obtaining unit is used to divide the association graph slice data based on the second hash algorithm to obtain at least one association graph partition data.

[0217] According to embodiments of this disclosure, the first obtaining module 910 may include a third obtaining submodule.

[0218] The third submodule is used to respond to a received graph data storage request by dividing the graph data to be stored using a node-based graph partitioning algorithm to obtain at least two graph slices to be stored.

[0219] According to embodiments of this disclosure, the graph data storage device 900 may further include a second acquisition module, a first deletion module, a second deletion module, a third storage module, and a fourth storage module.

[0220] The second acquisition module is used to obtain new target map tile data and new associated map tile data based on at least two map tile data to be stored in response to the detection of a storage switching command.

[0221] The first deletion module is used to delete the target map slice data stored in the GPU.

[0222] The second deletion module is used to delete the associated graph slice data stored in the internal memory.

[0223] The third storage module is used to store new target map slice data to the GPU.

[0224] The fourth storage module is used to store new associated graph tile data in the internal memory.

[0225] According to embodiments of this disclosure, the relationship between target graph tile data and associated graph tile data includes one of the following: there is no overlap between target graph tile data and associated graph tile data, and associated graph tile data includes target graph tile data.

[0226] According to embodiments of this disclosure, the target graph tile data includes at least one of target node-related data and target neighbor node-related data. The target node-related data includes at least one of target node data and target node feature data. The target neighbor node-related data includes at least one of target neighbor node data and target neighbor node feature data.

[0227] According to embodiments of this disclosure, the association graph tile data includes at least one of associated node-related data and associated neighbor node-related data. The associated node-related data includes at least one of associated node data and associated node feature data. The associated neighbor node-related data includes at least one of the following: associated neighbor node data and associated neighbor node feature data.

[0228] Figure 10 A block diagram of a graph data access device according to an embodiment of the present disclosure is shown schematically.

[0229] like Figure 10 As shown, the data access device 1000 may include a first acquisition module 1010 and a second acquisition module 1020.

[0230] The first acquisition module 1010 is used to acquire the identifier to be accessed in response to receiving a graph data access request.

[0231] The second acquisition module 1020 is used to acquire the access result from the target map tile data based on the matching identifier when it is determined that there is a matching identifier in the target map tile data that matches the identifier to be accessed.

[0232] According to embodiments of the present disclosure, the target image slice data is image data to be stored in the graphics processing unit (GPU) in the image data storage device according to embodiments of the present disclosure.

[0233] According to embodiments of this disclosure, the GPU includes at least one GPU card.

[0234] According to embodiments of this disclosure, the second acquisition module 1020 may include a first acquisition submodule, a third determination submodule, a sending submodule, and a receiving submodule.

[0235] The first acquisition submodule is used to obtain the access result from the target map slice data based on the matching identifier when it is determined that there is a matching identifier in the current target map partition data that matches the identifier to be accessed.

[0236] If it is determined that there is no matching identifier in the current target graph partition data that matches the identifier to be accessed,

[0237] The third determination submodule is used to determine the GPU card corresponding to the identifier to be accessed.

[0238] The sending submodule is used to send the access identifier to the GPU card corresponding to the access identifier, so that if the GPU card corresponding to the access identifier determines that there is a matching identifier in the target graph partition data of the GPU card corresponding to the access identifier, it can obtain the access result from the target graph slice data according to the matching identifier.

[0239] The receiving submodule is used in response to receiving an access result from the GPU card corresponding to the identifier to be accessed.

[0240] According to embodiments of this disclosure, the above-described graph data access device 1000 may further include a first sending module and a receiving module.

[0241] The first sending module is used to send the identifier to be accessed to the internal memory when it is determined that there is no matching identifier in the target graph partition data of the GPU card corresponding to the identifier to be accessed, so that the internal memory can obtain the access result from the associated graph slice data according to the matching identifier when it is determined that there is a matching identifier in the associated graph slice data.

[0242] A receiving module is configured to respond to receiving an access result from the GPU card corresponding to the access identifier, wherein the access result obtained by the GPU card corresponding to the access identifier is in response to receiving an access result from the internal memory.

[0243] According to embodiments of this disclosure, the associated graph tile data is the number of graphs to be stored in the internal memory in the graph data storage method according to embodiments of this disclosure.

[0244] According to embodiments of this disclosure, the above-described graph data access device 1000 may further include a creation module and an addition module.

[0245] Create a module to create the first access task based on the identifier to be accessed.

[0246] Add a module to add the first access task to the first task queue corresponding to the GPU.

[0247] According to embodiments of this disclosure, the second acquisition module 1020 may include a second acquisition submodule, a third acquisition submodule, and a fourth acquisition submodule.

[0248] The second acquisition submodule is used to acquire the first head task from the first task queue using the thread corresponding to the GPU.

[0249] The third acquisition submodule is used to obtain the access identifier from the first head task by utilizing the thread corresponding to the GPU, if it is determined that the first head task is the first access task.

[0250] The fourth acquisition submodule is used to obtain the access result from the target image slice data based on the matching identifier when the thread corresponding to the GPU determines that there is a matching identifier in the target image slice data that matches the identifier to be accessed.

[0251] Figure 11 A block diagram of a graph data access apparatus according to another embodiment of the present disclosure is shown schematically.

[0252] like Figure 11 As shown, the data access device 1100 may include a third acquisition module 1110 and a second transmission module 1120.

[0253] The third acquisition module 1110 is configured to, in response to receiving a target identifier from the graphics processing unit (GPU), acquire an access result from the associated graph tile data based on the matching identifier if it is determined that a matching identifier exists in the associated graph tile data that matches the target identifier.

[0254] The second sending module 1120 is used to send the access results to the GPU.

[0255] According to embodiments of the present disclosure, the associated graph tile data is graph data to be stored in the internal memory of the graph data storage device according to embodiments of the present disclosure.

[0256] According to embodiments of this disclosure, the above-described graph data access device 1100 may further include a third sending module and a fourth sending module.

[0257] If it is determined that there is no matching identifier in the association graph slice data that matches the identifier to be accessed,

[0258] The third sending module is used to send the access identifier to the external memory so that the external memory can obtain the access result from at least two map slice data to be stored.

[0259] The fourth sending module is used to send the access result to the GPU in response to receiving the access result from the external memory.

[0260] According to embodiments of the present disclosure, at least two plot data to be stored are plot data to be stored in a plot data storage device according to embodiments of the present disclosure.

[0261] According to embodiments of this disclosure, the third acquisition module 1110 may include a creation submodule, an addition submodule, a fifth acquisition submodule, a sixth acquisition submodule, and a seventh acquisition submodule.

[0262] Create a submodule to create a second access task based on the access identifier received from the GPU.

[0263] Add a submodule to add the second access task to the second task queue corresponding to the internal memory.

[0264] The fifth acquisition submodule is used to acquire the second head task from the second task queue using the thread corresponding to the internal memory.

[0265] The sixth acquisition submodule is used to obtain the access identifier from the second head task when it is determined that the second head task is the second access task, by utilizing the thread corresponding to the internal memory.

[0266] The seventh submodule is used to retrieve the access result from the association graph slice data based on the matching identifier when the thread corresponding to the internal memory determines that there is a matching identifier in the association graph slice data that matches the identifier to be accessed.

[0267] Figure 12 A block diagram of a training apparatus for a graph neural network model according to an embodiment of the present disclosure is shown schematically.

[0268] like Figure 12 As shown, the training device 1200 for the graph neural network model may include a determining module 1210, a fourth acquiring module 1220, a third obtaining module 1230, and a fifth sending module 1240.

[0269] The determination module 1210 is used to determine at least one target sampling node from the target map slice data based on the sampling strategy in response to receiving a model training request.

[0270] The fourth acquisition module 1220 is used to acquire at least one first-order neighbor node corresponding to at least one target sampling node from target graph tile data, associated graph tile data and at least two graph tile data to be stored, based on at least one target sampling node.

[0271] The third obtaining module 1230 is used to obtain at least one-order subgraph data based on the target sampling node related data of at least one target sampling node and the neighbor node related data of at least one first-order neighbor node.

[0272] The fifth sending module 1240 is used to send at least one-order subgraph data to the deep learning platform so that the deep learning platform can use the at least one-order subgraph data to train a graph neural network model.

[0273] According to embodiments of this disclosure, the target image tile data is data to be stored in the graphics processing unit (GPU) of the graph data storage device according to embodiments of this disclosure. The associated image tile data is image data to be stored in the internal memory of the graph data storage device according to embodiments of this disclosure. At least two images tile data to be stored are image data to be stored in the external memory of the graph data storage device according to embodiments of this disclosure.

[0274] According to embodiments of this disclosure, the determining module 1210 may include one of the following:

[0275] The fourth determination submodule is used to determine all target nodes in the target map slice data as target sampling nodes in response to the received model training request, based on the traversal sampling strategy.

[0276] The fifth determination submodule is used to, in response to receiving a model training request, determine at least one target sampling node from a portion of the target map slice data based on a conditional sampling strategy.

[0277] According to embodiments of this disclosure, the training apparatus 1200 for the graph neural network model described above may further include a generation module and an execution module.

[0278] The generation module is used to generate a storage switching instruction in response to receiving a training completion instruction from the deep learning platform.

[0279] The execution module is configured to, in response to a detected storage switching instruction, repeatedly execute the operation of obtaining at least one-order subgraph data and sending at least one-order subgraph data to a deep learning platform, so that the deep learning platform can train a graph neural network model using the at least one-order subgraph data, until a predetermined number of the at least two graph slices to be stored are determined to be the target graph slice data, and then complete the training operation of training the graph neural network model using the target graph slice data.

[0280] Figure 13 A block diagram of a graph data processing apparatus according to an embodiment of the present disclosure is shown schematically.

[0281] like Figure 13 As shown, the data processing device 1300 may include a fourth acquisition module 1310.

[0282] The fourth acquisition module 1310 is used to input the target graph data into the graph neural network model and obtain the output result.

[0283] According to embodiments of the present disclosure, the graph neural network model is trained using a training apparatus for graph neural network models according to embodiments of the present disclosure.

[0284] According to embodiments of this disclosure, this disclosure also provides an electronic device, a readable storage medium, and a computer program product.

[0285] According to an embodiment of the present disclosure, an electronic device includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the method described above.

[0286] According to embodiments of the present disclosure, a non-transitory computer-readable storage medium stores computer instructions, wherein the computer instructions are used to cause a computer to perform the method described above.

[0287] According to an embodiment of this disclosure, a computer program product includes a computer program that, when executed by a processor, implements the method described above.

[0288] Figure 14 The diagram schematically illustrates an electronic device suitable for implementing graph data storage methods, graph data access methods, graph neural network model training methods, and graph data processing methods according to embodiments of the present disclosure. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0289] like Figure 14As shown, the electronic device 1400 includes a computing unit 1401, which can perform various appropriate actions and processes according to a computer program stored in a read-only memory (ROM) 1402 or a computer program loaded from a storage unit 1408 into a random access memory (RAM) 1403. The RAM 1403 may also store various programs and data required for the operation of the electronic device 1400. The computing unit 1401, ROM 1402, and RAM 1403 are interconnected via a bus 1404. An input / output (I / O) interface 1405 is also connected to the bus 1404.

[0290] Multiple components in electronic device 1400 are connected to I / O interface 1405, including: input unit 1406, such as keyboard, mouse, etc.; output unit 1407, such as various types of monitors, speakers, etc.; storage unit 1408, such as disk, optical disk, etc.; and communication unit 1409, such as network card, modem, wireless transceiver, etc. Communication unit 1409 allows electronic device 1400 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0291] The computing unit 1401 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 1401 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 1401 performs the various methods and processes described above, such as graph data storage methods, graph data access methods, graph neural network model training methods, and graph data processing methods. For example, in some embodiments, the graph data storage methods, graph data access methods, graph neural network model training methods, and graph data processing methods can be implemented as computer software programs tangibly contained in a machine-readable medium, such as storage unit 1408. In some embodiments, part or all of the computer program can be loaded and / or installed on the electronic device 1400 via ROM 1402 and / or communication unit 1409. When the computer program is loaded into RAM 1403 and executed by computing unit 1401, one or more steps of the graph data storage method, graph data access method, graph neural network model training method, and graph data processing method described above can be performed. Alternatively, in other embodiments, computing unit 1401 can be configured to perform the graph data storage method, graph data access method, graph neural network model training method, and graph data processing method by any other suitable means (e.g., by means of firmware).

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

[0293] The program code used to implement the methods of this disclosure 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 apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be 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.

[0294] In the context of this disclosure, 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. A machine-readable medium 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 fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0295] 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 (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) 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).

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

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

[0298] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

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

Claims

1. A graph data storage method, comprising: In response to receiving a graph data storage request, the graph data to be stored is divided to obtain at least two graph slice data to be stored; Determine the target map slice data from the at least two map slice data to be stored; Based on the target map tile data, determine the associated map tile data from the map data to be stored; The target image slice data is stored in the graphics processing unit (GPU). The associated graph slice data is stored in the internal memory; as well as The at least two image slices to be stored are stored in an external memory; The relationship between the target graph slice data and the associated graph slice data includes one of the following: there is no intersection between the target graph slice data and the associated graph slice data, and the associated graph slice data includes the target graph slice data; The target graph slice data includes at least one of target node-related data and target neighbor node-related data; the target node-related data includes at least one of target node data and target node feature data; and the target neighbor node-related data includes at least one of target neighbor node data and target neighbor node feature data. The associated graph slice data includes at least one of associated node related data and associated neighbor node related data, the associated node related data includes at least one of associated node data and associated node feature data, and the associated neighbor node related data includes at least one of associated neighbor node data and associated neighbor node feature data.

2. The method according to claim 1, wherein, The GPU includes at least one GPU card; The step of storing the target image slice data in the graphics processing unit (GPU) includes: The target map slice data is divided to obtain at least one target map partition data; and The at least one target graph partition data is stored in at least one GPU card.

3. The method according to claim 2, wherein, The step of dividing the target map slice data to obtain at least one target map partition data includes: The target graph slice data is divided based on the first hash algorithm to obtain at least one target graph partition data.

4. The method according to claim 1, wherein, The internal memory includes at least one internal storage area; The step of storing the associated graph slice data in internal memory includes: The association graph slice data is divided to obtain at least one association graph partition data; and The at least one association graph partition data is stored in the at least one internal storage area.

5. The method according to claim 4, wherein, The step of dividing the association graph slice data to obtain at least one association graph partition data includes: The association graph slice data is divided based on the second hash algorithm to obtain at least one association graph partition data.

6. A graph data access method, comprising: In response to receiving a graph data access request, obtain the identifier to be accessed; as well as If it is determined that there is a matching identifier in the target image slice data that matches the identifier to be accessed, the access result is obtained from the target image slice data according to the matching identifier, wherein the target image slice data is the image data to be stored in the graphics processing unit (GPU) in the method of any one of claims 1 to 5.

7. The method according to claim 6, wherein, The GPU includes at least one GPU card; Wherein, the step of obtaining the access result from the target map tile data based on the matching identifier when it is determined that there is a matching identifier in the target map tile data that matches the identifier to be accessed includes: If it is determined that a matching identifier exists in the current target map partition data that matches the identifier to be accessed, the access result is obtained from the target map tile data based on the matching identifier; and If it is determined that there is no matching identifier in the current target graph partition data that matches the identifier to be accessed, Identify the GPU card corresponding to the identifier to be accessed; The access identifier is sent to the GPU card corresponding to the access identifier, so that if the GPU card corresponding to the access identifier determines that a matching identifier exists in the target map partition data of the GPU card corresponding to the access identifier, it can obtain an access result from the target map slice data based on the matching identifier; and In response to receiving an access result from the GPU card corresponding to the access identifier.

8. The method according to claim 7, further comprising: If it is determined that no matching identifier exists in the target graph partition data of the GPU card corresponding to the access identifier, the access identifier is sent to the internal memory. This allows the internal memory to retrieve the access result from the associated graph slice data based on the matching identifier if it determines that a matching identifier exists in the associated graph slice data. The associated graph slice data is the graph data to be stored in the internal memory as described in any one of claims 1 to 5. In response to receiving an access result from the GPU card corresponding to the access identifier, wherein the access result obtained by the GPU card corresponding to the access identifier is in response to receiving the access result from the internal memory.

9. The method according to any one of claims 6 to 8, further comprising: Based on the identifier to be accessed, a first access task is created; Add the first access task to the first task queue corresponding to the GPU; Wherein, the step of obtaining the access result from the target map tile data based on the matching identifier when it is determined that there is a matching identifier in the target map tile data that matches the identifier to be accessed includes: The first head task is retrieved from the first task queue using the thread corresponding to the GPU; When the thread corresponding to the GPU determines that the first header task is the first access task, it retrieves the access identifier from the first header task; and If a thread corresponding to the GPU determines that there is a matching identifier in the target image slice data that matches the identifier to be accessed, the access result is obtained from the target image slice data based on the matching identifier.

10. A graph data access method, comprising: In response to receiving a pending access identifier from the graphics processing unit (GPU), if it is determined that a matching identifier exists in the associated graph tile data that matches the pending access identifier, an access result is obtained from the associated graph tile data based on the matching identifier, wherein the associated graph tile data is the graph data to be stored in the internal memory as described in any one of claims 1 to 5; and The access result is sent to the GPU.

11. The method of claim 10, further comprising: If it is determined that there is no matching identifier in the association graph slice data that matches the identifier to be accessed, Sending the access identifier to an external memory so that the external memory obtains the access result from at least two map tile data to be stored, wherein the at least two map tile data to be stored are the data to be stored in any one of claims 1 to 5; and In response to receiving the access result from the external memory, the access result is sent to the GPU.

12. The method according to claim 10 or 11, wherein, In response to receiving a pending access identifier from the graphics processing unit (GPU), if it is determined that a matching identifier exists in the associated graph tile data that matches the pending access identifier, the access result is obtained from the associated graph tile data based on the matching identifier, including: In response to receiving a pending access identifier from the GPU, a second access task is created based on the pending access identifier; Add the second access task to the second task queue corresponding to the internal memory; The second head task is retrieved from the second task queue using the thread corresponding to the internal memory; When the thread corresponding to the internal memory determines that the second header task is the second access task, it retrieves the access identifier from the second header task; and If a thread corresponding to the internal memory determines that there is a matching identifier in the association graph slice data that matches the identifier to be accessed, the access result is obtained from the association graph slice data based on the matching identifier.

13. A method for training a graph neural network model, comprising: In response to receiving a model training request, at least one target sampling node is determined from the target map slice data based on a sampling strategy, wherein the target map slice data is the data to be stored in the graphics processing unit (GPU) in any one of claims 1 to 5. Based on the at least one target sampling node, at least one first-order neighbor node corresponding to the at least one target sampling node is obtained from one of the target graph slice data, the associated graph slice data, and at least two graph slice data to be stored, wherein the associated graph slice data is the graph data to be stored stored in the internal memory in the method of any one of claims 1 to 5, and the at least two graph slice data to be stored is the graph data to be stored stored in the external memory in the method of any one of claims 1 to 5; Based on the target sampling node related data of the at least one target sampling node and the neighbor node related data of the at least one first-order neighbor node, at least one first-order subgraph data is obtained; and The at least one-order subgraph data is sent to a deep learning platform so that the deep learning platform can train the graph neural network model using the at least one-order subgraph data.

14. The method according to claim 13, wherein, In response to receiving a model training request, at least one target sampling node is determined from the target map slice data based on a sampling strategy, including one of the following: In response to receiving the model training request, based on the traversal sampling strategy, all target nodes in the target map slice data are determined as the target sampling nodes; as well as In response to receiving the model training request, based on the conditional sampling strategy, a portion of the target nodes in the target map slice data are identified as the at least one target sampling node.

15. The method according to claim 13 or 14, further comprising: In response to receiving a training completion instruction from the deep learning platform, a storage switching instruction is generated; as well as In response to the detection of the storage switching instruction, if new target graph slice data and new associated graph slice data are obtained based on the at least two graph slice data to be stored, the operation of obtaining the at least one-order subgraph data and sending the at least one-order subgraph data to the deep learning platform is repeated, so that the deep learning platform can use the at least one-order subgraph data to train the graph neural network model, until a predetermined number of the graph slice data to be stored in the at least two graph slice data to be stored are determined to be the target graph slice data, and the training operation of training the graph neural network model using the target graph slice data is completed.

16. A graph data processing method, comprising: The target graph data is input into a graph neural network model to obtain the output result, wherein the graph neural network model is trained using the method according to any one of claims 13 to 15.

17. A graph data storage device, comprising: The first obtaining module is used to respond to receiving a graph data storage request by dividing the graph data to be stored and obtaining at least two graph slice data to be stored; The second obtaining module is used to determine target map tile data from the at least two map tile data to be stored, and to determine associated map tile data from the map data to be stored based on the target map tile data; The first storage module is used to store the target image slice data to the graphics processing unit (GPU). The second storage module is used to store the associated graph slice data into the internal memory; as well as The third storage module is used to store the at least two image slices to be stored to an external memory; The relationship between the target graph slice data and the associated graph slice data includes one of the following: there is no intersection between the target graph slice data and the associated graph slice data, and the associated graph slice data includes the target graph slice data; The target graph slice data includes at least one of target node-related data and target neighbor node-related data; the target node-related data includes at least one of target node data and target node feature data; and the target neighbor node-related data includes at least one of target neighbor node data and target neighbor node feature data. The associated graph slice data includes at least one of associated node related data and associated neighbor node related data, the associated node related data includes at least one of associated node data and associated node feature data, and the associated neighbor node related data includes at least one of associated neighbor node data and associated neighbor node feature data.

18. The apparatus according to claim 17, wherein, The GPU includes at least one GPU card; The first storage module includes: The first obtaining submodule is used to divide the target map slice data to obtain at least one target map partition data; and The first storage submodule is used to store the at least one target graph partition data to at least one GPU card.

19. The apparatus according to claim 18, wherein, The first obtaining submodule includes: The first obtaining unit is used to divide the target map slice data based on the first hash algorithm to obtain the at least one target map partition data.

20. The apparatus according to claim 17, wherein, The internal memory includes at least one internal storage area; The second storage module includes: The second obtaining submodule is used to divide the association graph slice data to obtain at least one association graph partition data; and The second storage submodule is used to store the at least one association graph partition data to the at least one internal storage area.

21. The apparatus according to claim 20, wherein, The second obtaining submodule includes: The second obtaining unit is used to divide the association graph slice data based on the second hash algorithm to obtain the at least one association graph partition data.

22. A graph data access device, comprising: The first acquisition module is used to acquire the identifier to be accessed in response to receiving a graph data access request; as well as The second acquisition module is configured to, when it is determined that there is a matching identifier in the target image slice data that matches the identifier to be accessed, acquire an access result from the target image slice data according to the matching identifier, wherein the target image slice data is image data to be stored in the graphics processor GPU in the device according to any one of claims 17 to 21.

23. The apparatus according to claim 22, wherein, The GPU includes at least one GPU card; The second acquisition module includes: The first acquisition submodule is configured to, when it is determined that a matching identifier exists in the current target map partition data that matches the identifier to be accessed, acquire the access result from the target map tile data based on the matching identifier; and If it is determined that there is no matching identifier in the current target graph partition data that matches the identifier to be accessed, The first determining submodule is used to determine the GPU card corresponding to the identifier to be accessed; A sending submodule is configured to send the access identifier to the GPU card corresponding to the access identifier, so that if the GPU card corresponding to the access identifier determines that a matching identifier exists in the target graph partition data of the GPU card corresponding to the access identifier, it can obtain an access result from the target graph slice data based on the matching identifier; and The receiving submodule is used in response to receiving an access result from the GPU card corresponding to the access identifier.

24. The apparatus of claim 23, further comprising: A first sending module is configured to send the access identifier to an internal memory when it is determined that no matching identifier exists in the target graph partition data of the GPU card corresponding to the access identifier, so that the internal memory, upon determining that a matching identifier exists in the associated graph slice data, obtains the access result from the associated graph slice data based on the matching identifier, wherein the associated graph slice data is the graph data to be stored in the internal memory in the apparatus of any one of claims 17 to 21; and A receiving module is configured to respond to receiving an access result from a GPU card corresponding to the access identifier, wherein the access result obtained by the GPU card corresponding to the access identifier is in response to receiving an access result from the internal memory.

25. The apparatus according to any one of claims 22 to 24, further comprising: A creation module is used to create a first access task based on the access identifier; An add module is used to add the first access task to the first task queue corresponding to the GPU; The second acquisition module includes: The second acquisition submodule is used to acquire the first head task from the first task queue using the thread corresponding to the GPU; The third acquisition submodule is used to acquire the access identifier from the first header task by utilizing the thread corresponding to the GPU, provided that the first header task is determined to be the first access task; and The fourth acquisition submodule is used to acquire the access result from the target image slice data based on the matching identifier when the thread corresponding to the GPU determines that there is a matching identifier in the target image slice data that matches the identifier to be accessed.

26. A graph data access device, comprising: The third acquisition module is configured to, in response to receiving a pending access identifier from the graphics processing unit (GPU), and upon determining that a matching identifier exists in the associated graph slice data that matches the pending access identifier, acquire an access result from the associated graph slice data based on the matching identifier, wherein the associated graph slice data is pending storage graph data stored in the internal memory in the apparatus of any one of claims 17-21; and The second sending module is used to send the access result to the GPU.

27. The apparatus of claim 26, further comprising: If it is determined that there is no matching identifier in the association graph slice data that matches the identifier to be accessed, A third sending module is configured to send the access identifier to an external memory so that the external memory can obtain the access result from at least two map tile data to be stored, wherein the at least two map tile data to be stored are data to be stored in the apparatus of any one of claims 17-21; and The fourth sending module is used to send the access result to the GPU in response to receiving the access result from the external memory.

28. The apparatus according to claim 26 or 27, wherein, The third acquisition module includes: A submodule is created to create a second access task based on the access identifier received from the GPU in response to receiving the access identifier. Add a submodule to add the second access task to the second task queue corresponding to the internal memory; The fifth acquisition submodule is used to acquire the second head task from the second task queue using the thread corresponding to the internal memory; The sixth acquisition submodule is used to acquire the access identifier from the second header task when it is determined that the second header task is the second access task, using the thread corresponding to the internal memory; and The seventh acquisition submodule is used to acquire the access result from the association graph slice data based on the matching identifier when the thread corresponding to the internal memory determines that there is a matching identifier in the association graph slice data that matches the identifier to be accessed.

29. A training device for a graph neural network model, comprising: A determination module is configured to, in response to receiving a model training request, determine at least one target sampling node from target map slice data based on a sampling strategy, wherein the target map slice data is data to be stored in the graphics processing unit (GPU) in the apparatus of any one of claims 17 to 21; The fourth acquisition module is configured to acquire, based on the at least one target sampling node, at least one first-order neighbor node corresponding to the at least one target sampling node from the target graph slice data, the associated graph slice data, and at least two graph slice data to be stored, wherein the associated graph slice data is graph data to be stored stored in the internal memory of the device according to any one of claims 17 to 21, and the at least two graph slice data to be stored is graph data to be stored stored in the external memory of the device according to any one of claims 17 to 21; The third obtaining module is used to obtain at least one-order subgraph data based on the target sampling node related data of the at least one target sampling node and the neighbor node related data of the at least one first-order neighbor node; and The fifth sending module is used to send the at least one-order subgraph data to the deep learning platform so that the deep learning platform can use the at least one-order subgraph data to train the graph neural network model.

30. The apparatus according to claim 29, wherein, The determining module includes one of the following: The second determining submodule is used to, in response to receiving the model training request, determine all target nodes in the target map slice data as the target sampling nodes based on the traversal sampling strategy; as well as The third determination submodule is used to, in response to receiving the model training request, determine a portion of the target nodes in the target map slice data as the at least one target sampling node based on the conditional sampling strategy.

31. The apparatus according to claim 29 or 30, further comprising: The generation module is used to generate a storage switching instruction in response to receiving a training completion instruction from the deep learning platform; as well as An execution module is configured to, in response to detecting the storage switching instruction, repeatedly execute the operation of obtaining the at least one-order subgraph data and sending the at least one-order subgraph data to the deep learning platform, so that the deep learning platform can train the graph neural network model using the at least one-order subgraph data, until a predetermined number of the at least two graph slices to be stored are determined to be the target graph slice data, and then complete the training operation of training the graph neural network model using the target graph slice data.

32. A graph data processing apparatus, comprising: The fourth acquisition module is used to input the target graph data into the graph neural network model and obtain the output result, wherein the graph neural network model is trained using the apparatus according to any one of claims 29 to 31.

33. An electronic device, comprising: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1 to 16.

34. A non-transitory computer-readable storage medium storing computer instructions, wherein, The computer instructions are used to cause the computer to perform the method according to any one of claims 1 to 16.

Images