CN116089748A - Drug depth knowledge graph rendering and updating method, system and device - Google Patents
Drug depth knowledge graph rendering and updating method, system and device Download PDFInfo
- Publication number
- CN116089748A CN116089748A CN202211411193.0A CN202211411193A CN116089748A CN 116089748 A CN116089748 A CN 116089748A CN 202211411193 A CN202211411193 A CN 202211411193A CN 116089748 A CN116089748 A CN 116089748A
- Authority
- CN
- China
- Prior art keywords
- node
- knowledge graph
- rendering
- nodes
- request
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/957—Browsing optimisation, e.g. caching or content distillation
- G06F16/9577—Optimising the visualization of content, e.g. distillation of HTML documents
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/23—Updating
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/30—Information retrieval; Database structures therefor; File system structures therefor of unstructured textual data
- G06F16/36—Creation of semantic tools, e.g. ontology or thesauri
- G06F16/367—Ontology
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Life Sciences & Earth Sciences (AREA)
- Animal Behavior & Ethology (AREA)
- Computational Linguistics (AREA)
- Image Generation (AREA)
Abstract
The invention discloses a method, a system and a device for rendering and updating a medicine depth knowledge graph, which can solve the problems of rendering stuck, poor experience, poor performance and the like caused by large node data level and frequent small-scale updating of the node relation of the knowledge graph (including the addition, deletion and sequential adjustment of nodes) in the medicine depth knowledge graph. The request scheduling algorithm in the invention invokes the performance of the CPU of the client to the greatest extent by establishing two request pools, and requests a large amount of data of the drug knowledge graph in batches according to a certain method on the premise of the maximum parallel network request which can be met by the client, thereby solving the problem of time blocking caused by overlarge data quantity in the network request part.
Description
Technical Field
The invention relates to the technical field of medical knowledge graph and deep learning, in particular to a method, a system and a device for rendering and updating a medicine deep knowledge graph.
Background
The medicine depth knowledge graph is a practical application of the knowledge graph in the field of medicine science. The medicine depth knowledge map contains the basic information of medicines, chemical structures, adverse reactions, action targets, related genes, action paths and other field information, and key information of the researched medicines is intuitively presented by using a visual technology through the tree-type mapping relation of the knowledge map, so that inquiry and investigation of medicine researchers and clinicians are facilitated. The medicine depth knowledge graph mainly has two characteristics different from the general knowledge graph, namely, the data level of the nodes in the medicine depth knowledge graph is larger, and the graph can be frequently updated in a small-scale node relation (including the addition, deletion and sequential adjustment of the nodes). Based on the two characteristics, the adoption of the general knowledge graph rendering scheme can bring results of rendering stuck, poor experience, poor performance and the like.
In the prior art, the rendering of the universal knowledge graph by the browser is based on scalable vector graphics (Scalable Vector Graphics, SVG for short), and the method is not good at rendering of large data volume, can cause web page collapse and death, and brings bad experience to users. In the method for updating the tree graph in the knowledge graph on a large scale, which is proposed in the patent with the application publication number of CN 110647664A, the problem of performance during updating of the knowledge graph with large data volume is solved: when updating occurs, a new knowledge graph is updated on the original knowledge graph by comparing new data with old data and applying the idea of replacing nodes. But this replacement is incomplete. The simple linear comparison replacement does not consider how to fully utilize the relation between the nodes and the node sequence in the original knowledge graph, so that the old nodes cannot be multiplexed in place to the greatest extent. Such replacement still causes a large number of DOM operations, and the problem is not completely solved.
Disclosure of Invention
The invention aims to provide a method, a system and a device for rendering and updating a medicine depth knowledge graph, which are used for overcoming the defects in the prior art.
In order to achieve the above purpose, the present invention provides the following technical solutions:
the invention discloses a drug depth knowledge graph rendering and updating method, which comprises the following steps:
s1, managing a network request: on the premise of maximum parallel network requests met by a client, carrying out batch requests on big data of a medicine knowledge graph, wherein the batch requests comprise a to-be-requested pool queue and an on-request pool queue which are set according to graph node magnitude and experience value M of the client which initiates the network requests in parallel and does not cause blocking, the network requests are pressed into the to-be-requested pool queue, M requests are extracted from the to-be-requested pool queue and pressed into the on-request pool queue to carry out the network requests, all the requests are circularly sent, and the client obtains all network request results and stores the network request results in a knowledge graph node set;
s2, rendering actual document object model nodes of the drug knowledge graph, wherein the rendering method based on a browser request animation framework is adopted to perform step-by-step rendering on the block rendering of a large data volume according to the granularity of node groups in the drug knowledge graph, and the first mounting and rendering of the drug depth knowledge graph nodes are completed;
And S3, combining a greedy algorithm, dynamic programming and a backtracking algorithm, comparing the data of the drug knowledge maps before and after updating, calculating to obtain a minimum knowledge map change result, and further operating child nodes in a real document object model of the original knowledge map to finish the rendering of the new map.
Preferably, the specific substeps of the step S1 are as follows:
s11, calculating the node magnitude of the map, and calculating the request pool capacity according to the magnitude and the node group capacity requested by each client;
s12, initializing a to-be-requested pool queue and a requesting pool queue, wherein the capacity of the requesting pool queue is M, and M represents an experience value that a client side initiates network requests in parallel and does not cause blocking;
s13, initializing N network requests, and setting a monitoring event function for the network requests;
s14, pressing N network requests into a to-be-requested pool queue, and then taking out the first M requests from the to-be-requested pool queue according to the natural number from small to large arrangement order;
s15, the client initiates network connection to M requests in the request pool queue simultaneously and in parallel, and makes a network request, and after any one request in the request queue is successful, the request triggers a monitoring event function to issue a notification of successful request to the client;
S16, after receiving the notice of successful request, the client stores the network request result in the knowledge graph node set, and pops up the request from the request pool queue, and then takes the next request from the request pool queue to press into the request pool queue;
s17, repeating the steps S15 and S16 until all the requests are sent, and obtaining all the network request results by the client and storing the network request results in the knowledge graph node set.
Preferably, in the step S2, when the client draws the knowledge graph for the first time, the rendering method based on the browser request animation framework is adopted to perform batch optimized rendering, and the specific process is as follows:
s21, recording the node set to be rendered as the knowledge graph node set obtained in the step S1, wherein the node set to be rendered contains all node information in the knowledge graph to be rendered;
s22, setting a client refreshing frame rate;
s23, setting a callback function of a browser for rendering a knowledge graph by the client to request a rendering method of the animation framework;
s24, setting the calling time for triggering the callback function according to the refresh frame rate of the client;
and S25, circularly using a callback function, and rendering all the node sets to be rendered.
Preferably, in the step S3, when the data of the depth knowledge graph of the drug changes, the client draws the updated knowledge graph, and supplements, deletes or modifies the knowledge graph nodes based on the original knowledge graph, and the specific method is as follows:
S31, defining a data structure of an abstract syntax tree, wherein the data structure is composed of triples comprising an id of the node, a father node id corresponding to the node and a child node id set pointed by the node in a knowledge graph;
s32, processing the original knowledge graph node set to obtain an original abstract syntax tree of the converted knowledge graph; adopting a request scheduling method to obtain a new knowledge graph node set and an updated abstract syntax tree;
s33, circularly traversing the original abstract syntax tree and the updated abstract syntax tree, finding out the same head and tail of the original abstract syntax tree and the updated abstract syntax tree, performing traversing comparison, and respectively marking the rest nodes which are not compared in the original abstract syntax tree and the updated abstract syntax tree as C 0 And C 1 ；
S34, pair C 1 Establishing a mapping relation between the nodes, wherein the mapping relation is expressed as index of subscript pointing to the set where the node is located from the node identification of the node;
s35, establishing an index set, wherein the elements of the index set are expressed as C 1 The node element in C 0 Index of (a);
s36, traversing C 0 Determining index of index in new set according to node identification of node and mapping relation established above, establishing an initial index set for recording index of subscript of the old node in the new set;
S37, traversing the initial index set, and perfecting the index set through a mapping method;
s38, adopting a greedy algorithm, dynamic programming and a backtracking algorithm to obtain the longest incremental subsequence of the index set;
and S39, updating the knowledge graph according to the index set and the longest incremental subsequence thereof.
Preferably, the specific substeps of step S33 are as follows:
s331: comparing all nodes of the original abstract syntax tree and the updated abstract syntax tree from the root node, and recording that traversing nodes in the original abstract syntax tree and the updated abstract syntax tree are respectively an original node identifier and a new node identifier;
s332: traversing from the head to the tail, if the original node identification is the same as the new node identification, continuing to compare downwards until at least one of the original abstract syntax tree and the updated abstract syntax tree completes traversing of all nodes, ending traversing, and entering step S334; if the original node identification is different from the new node identification, the traversal is directly ended, and the step S333 is entered;
s333: sequentially comparing forward from the tail until the traversal is different from the original node identification and the new node identification, ending the traversal, and entering step S334;
s334: if all the nodes in the original abstract syntax tree are compared, and the nodes which are not compared exist in the updated abstract syntax tree, the nodes are newly added nodes, a client calls a function interface for creating new nodes in batches to generate a new node document object model of a knowledge graph, and calls the function interface to mount the created nodes on the appointed node position to realize rendering;
If all the nodes in the updated abstract syntax tree are compared, and the nodes which are not compared exist in the original abstract syntax tree, the nodes are deleted nodes, and the client side calls function interfaces of the deleted nodes in batches;
if nodes in the original abstract syntax tree and the updated abstract syntax tree are not compared, defining the rest nodes as unknown child nodes, and respectively marking the unknown child nodes as C 0 And C 1
Preferably, the step S38 specifically includes:
s381: creating a sequence set representing the stored maximum increment sub-sequence index as the longest increment sub-sequence sought;
s382: creating a precursor node set, and when a new value is newly added or replaced in the sequence set, adding an item to the precursor node set at the same time, wherein the item is an index of a previous item corresponding to the current item;
s383: traversing the elements in the index set from the second element, marking the elements as num, and judging whether the num is larger than the value corresponding to the last element in the sequence set in the index set; if yes, go to step S384; if not, go to step S385;
s384: adopting a dynamic programming idea, marking the index corresponding to the current num in the index set as j, adding j into the sequence set, simultaneously, recording the previous index of j in the sequence set into the precursor node set, and enabling the sequence set to be the longest increment subsequence;
S385: adopting a greedy algorithm idea, finding a first index larger than the current value by using a dichotomy, replacing the index, replacing the corresponding value in the sequence set by using the current index, and storing the previous value of the corresponding value in the sequence set into a backtracking set; and then backtracking correction is carried out, starting from the last bit, backtracking is carried out on the backtracking set obtained in the front, and the longest incremental subsequence is obtained.
Preferably, the backtracking method in step S385 specifically includes: recording variables epsilon and eta, wherein the epsilon initial value is the length of the sequence set, and the eta initial value is the last value in the sequence set; traversing the precursor node set in a reverse order, and reducing epsilon by one; judging whether epsilon is not less than 0, if so, searching forwards according to the precursor node, correcting the value of the epsilon term in the sequence set to eta, and correcting the eta to eta in the precursor node set; if not, the backtracking is ended, and the sequence set is the longest increment subsequence.
The invention discloses a drug depth knowledge graph rendering and updating system, which comprises the following modules:
request scheduling module: the system is used for managing network requests in the system, and large data of the medicine knowledge graph are requested in batches on the premise of the maximum parallel network requests which can be met by the client;
And a knowledge graph rendering module: the method comprises the steps that the method is used for rendering actual document object model nodes of the knowledge graph in the system, and the first mounting and rendering of the medicine depth knowledge graph are completed through function interface calling of the page element document object model in the script language; and when the data of the medicine nodes are updated, the updated medicine depth knowledge map is rendered through operations such as adding, deleting and moving the original knowledge map nodes.
And a knowledge graph updating module: and the method is used for comparing the data of the medicine knowledge maps before and after updating, calculating to obtain the minimum knowledge map change result, and further operating the child node document object model of the old knowledge map to finish the rendering of the new map.
The invention discloses a device for rendering and updating a medicine depth knowledge graph, which comprises a memory and one or more processors, wherein executable codes are stored in the memory, and the one or more processors are used for realizing the method for rendering and updating the medicine depth knowledge graph when executing the executable codes.
The invention has the beneficial effects that:
1. the method for updating and rendering the large-data-volume knowledge graph can solve the problems of rendering stuck, poor experience, poor performance and the like caused by large node data level and frequent small-scale knowledge graph node relation updating (including node addition, node deletion and sequence adjustment) in the medicine depth knowledge graph.
2. The request scheduling algorithm in the invention invokes the performance of the CPU of the client to the greatest extent by establishing two request pools, and requests a large amount of data of the drug knowledge graph in batches according to a certain method on the premise of the maximum parallel network request which can be met by the client, thereby solving the problem of time blocking caused by overlarge data quantity in the network request part.
3. The rAF method based on the client side realizes the operation processing of a plurality of nodes of a node group in each frame and the unified completion of the mounting and rendering of a plurality of knowledge graph nodes. Fully utilizing the performance of each frame of the client, centralizing all DOM operations in each frame, and completing rendering operations in one redrawing or reflow; by dividing the block rendering of a large amount of data according to granularity, the non-cartoon rendering of a large amount of data knowledge maps is realized by using the recursion call of the rAF method.
4. The knowledge graph updating module in the system obtains the variation result of the true node DOM of the knowledge graph before updating based on the minimum incremental subsequence by completing the comparison of the data before and after updating the depth knowledge graph of the medicine, and can operate the child nodes of the old knowledge graph less by multiplexing the true node DOM in situ, thereby completing the rendering of the new graph faster.
Drawings
FIG. 1 is a main flow chart of an embodiment of the present invention;
FIG. 2 is a flow chart of a request scheduling method according to an embodiment of the present invention;
FIG. 3 is a flowchart of a knowledge graph update rendering method according to an embodiment of the present invention;
fig. 4 is a schematic diagram of an apparatus according to an embodiment of the present invention.
Detailed Description
The present invention will be further described in detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present invention more apparent. It should be understood that the detailed description and specific examples, while indicating the invention, are intended for purposes of illustration only and are not intended to limit the scope of the invention. In addition, in the following description, descriptions of well-known structures and techniques are omitted so as not to unnecessarily obscure the present invention.
For the convenience of understanding the present invention, the terms used in the present invention will be explained first:
DOM: the document object model (Document Object Model), which is a platform and language-neutral interface, allows programs and scripts to dynamically access and update the content, structure, and style of a document. The operating time cost of the browser to the HTML DOM is the bottleneck for front-end rendering, and front-end optimization tends to spread around how much less to operate the DOM.
The longest increasing subsequence: in a given sequence of values, a sub-sequence is found such that the values of the sub-sequence elements are sequentially incremented and the length of the sub-sequence is as large as possible. The elements in the longest incremental subsequence are not necessarily contiguous in the original sequence.
Greedy algorithm: the choice that appears to be best at the present time is always made when solving the problem. That is, not considered in terms of overall optimality, what he did is a locally optimal solution in a sense.
Dynamic programming: is a method used in mathematics, management science, computer science, economics and bioinformatics to solve complex problems by decomposing the original problem into relatively simple sub-problems.
Abstract syntax tree: in computer science, an abstract syntax tree (Abstract Syntax Tree, AST) is an abstract representation of the source code syntax structure. It represents the syntax structure of a programming language in the form of a tree, each node on the tree representing a structure in the source code.
Redrawing and reflow when some elements in the rendering tree need to update attributes that only affect the appearance, style, and not the layout operation, we call such operation redrawing. When a part (or all) of the browser rendering tree needs to be reconstructed due to the change of the size, layout, hiding, etc. of the elements, the operation of the layout is affected, and such operation is called reflow. Both redrawing and reflow cause the browser to recalculate the style and re-operate the DOM for rendering, a time consuming operation.
The invention provides a request scheduling optimization method, which is used for carrying out batch request on a large amount of data of a medicine knowledge graph according to a certain method on the premise of the maximum parallel network request which can be met by a client, so that the problem of time blocking caused by overlarge data in a network request part is solved. Meanwhile, the blocking rendering of a large amount of data is performed step by step according to the granularity of the node groups in the knowledge graph, and the first mounting and rendering of the drug depth knowledge graph nodes are completed without blocking based on the browser request animation frames (request Animation Frame, rAF). In addition, aiming at the secondary rendering after the updating of the medicine knowledge graph data, combining with algorithm ideas such as greedy algorithm, dynamic programming, backtracking and the like, a method for updating and rendering the large data amount knowledge graph is provided, the updated change node of the knowledge graph is obtained through calculation, and the real DOM of the original knowledge graph node is multiplexed, so that only the change node part is updated. Thus, unnecessary performance overhead is avoided, and the secondary rendering time is greatly optimized.
As shown in fig. 1, an embodiment of the present invention provides a method for rendering and updating a depth knowledge graph of a drug, including the following steps:
S1, managing a network request: on the premise of maximum parallel network requests met by a client, carrying out batch requests on big data of a medicine knowledge graph, wherein the batch requests comprise a to-be-requested pool queue and an on-request pool queue which are set according to graph node magnitude and experience value M of the client which initiates the network requests in parallel and does not cause blocking, the network requests are pressed into the to-be-requested pool queue, M requests are extracted from the to-be-requested pool queue and pressed into the on-request pool queue to carry out the network requests, all the requests are circularly sent, and the client obtains all network request results and stores the network request results in a knowledge graph node set;
s2, rendering actual document object model nodes of the drug knowledge graph, wherein the rendering method based on a browser request animation framework is adopted to perform step-by-step rendering on the block rendering of a large data volume according to the granularity of node groups in the drug knowledge graph, and the first mounting and rendering of the drug depth knowledge graph nodes are completed;
and S3, combining a greedy algorithm, dynamic programming and a backtracking algorithm, comparing the data of the drug knowledge maps before and after updating, calculating to obtain a minimum knowledge map change result, and further operating child nodes in a real document object model of the original knowledge map to finish the rendering of the new map.
The specific method of the embodiment of the invention is as follows:
firstly, recording the magnitude of the number of the knowledge graph nodes as V.
According to the magnitude V, calculating to obtain the capacity N of the request pool according to the following formula;
where n is the node group capacity per client request, i.e., the number of nodes in each group. Every n nodes are a knowledge graph node group. In this embodiment, n is set to 1000, and the specific value can be dynamically adjusted by performance. The formula is given by the magnitude divided by the node group capacity, rounded up. The total capacity of the request pool is obtained.
The pending request pool queue and the requesting pool queue are defined and respectively marked as alpha and beta. The capacity of the to-be-requested pool queue alpha is N calculated in the last step, and the capacity M of the requesting pool queue beta represents an empirical value that a client can initiate network requests in parallel and does not cause blocking. In this embodiment, let m=6. Meanwhile, the number of transmitted requests is recorded as phi. The initial value of phi is noted as 0.
The client initiates a network request to the server according to a certain request scheduling method, and the specific method is as follows:
firstly, initializing N network requests, setting a monitoring event function f for the network requests, wherein the function is defined as that after a request success event is monitored, a notification is issued to a client;
Pressing the N network requests into a to-be-requested pool queue alpha;
then, from the queue alpha, taking the first M requests according to the arrangement sequence of natural numbers from small to large, popping up the alpha queue, and pressing into the request pool queue beta;
then, the client initiates network connection to M requests in the beta queue simultaneously in parallel, and performs network request;
when any one of the M requests is successful, the request triggers the function f, and a notification of the success of the request is issued to the client. And after receiving the monitoring notification of the request success event, the client stores the network request result in a knowledge graph node set response. Simultaneously, the beta queue pops up the request, sequentially removes a network request from alpha to pop up the queue alpha and pushes it down the queue beta. And simultaneously operating phi to increase by 1. Starting the circulation;
when Φ=n, that is, the number of transmitted requests is equal to the total number of queues to be requested, all requests are transmitted. The client obtains a final result set response. Otherwise, it is stated that the requests in α have not been completed completely, and the wait loop is continued to end.
According to the request scheduling method, the CPU performance of the client can be fully utilized, and the network request is sent in a multi-process manner under the constraint of the browser single-thread script executor, so that the script execution is not blocked, and the acquisition of the medicine depth knowledge graph data can be rapidly and parallelly completed. The specific process is shown in fig. 2.
And step two, when the client draws the knowledge graph for the first time, adopting a rAF-based rendering method to conduct batch optimized rendering. The specific method comprises the following steps:
and 2.1, firstly, recording a node set to be rendered as S, wherein S is a response set obtained in the step. According to the above process, S contains all node information in the knowledge graph to be rendered, and the elements in the set
Is a set of node information for each node group. Can be expressed as: />
。
And 2.2, recording the refresh frame rate of the client as f. The time interval for client rendering varies with the refresh frequency of the browser. Typically, this frequency is 60 frames per second. I.e. one frame is 16 milliseconds.
And 2.3, recording the function of the client side rendering knowledge graph as G. And setting G as a callback function of the rAF method. The time for triggering the function G is that each frame refreshed by the client, namely, the function G is called once every 1/f second, and the rendering of the knowledge graph node group si is completed once.
And 2.4, cycling the method, and rendering all the S.
Therefore, the rAF method based on the client side realizes that n nodes of a node group are operated and processed in each frame and the mounting and rendering of n knowledge graph nodes are uniformly completed.
The beneficial effects achieved by adopting the method are as follows: fully utilizing the performance of each frame of the client, centralizing all DOM operations in each frame, and completing rendering operations in one redrawing or reflow; by dividing the block rendering of large data volume according to granularity, the mounting and rendering of the knowledge graph nodes can be completed within 16×N milliseconds by using the recursive call of the rAF method. In this embodiment, taking a drug depth knowledge graph of 10 ten thousand order of nodes as an example, n=100 is calculated by the above procedure. Only 1.6 seconds is needed, so that a knowledge graph with large node capacity can be rendered on the client side without blocking. Waiting time is greatly reduced, and rendering efficiency of the client is improved.
And thirdly, when the data of the depth knowledge graph of the medicine changes, the client draws the updated knowledge graph, and the node of the knowledge graph needs to be supplemented, deleted or modified on the basis of the original knowledge graph. In order to pursue higher performance and quickly render the updated knowledge graph, the invention provides a method for updating and rendering the knowledge graph with large data volume. The method comprises the following steps:
step 3.1, first, a data structure of an abstract syntax tree (hereinafter abbreviated as AST) is defined. The data structure is composed of (nodeId, sourceId, targetIds) triples, which are respectively expressed as an id of the node, a father node id corresponding to the node and a child node id set pointed by the node in the knowledge graph. As shown in the table below.
The knowledge graph node truly DOM operation API is recorded, and the following table is concrete.
And 3.2, traversing all nodes in the original knowledge graph node set response, converting elements in the set into an AST format, and converting the original data set into a set meeting the AST format. Recording the original knowledge graph node set as response 0 AST of the converted knowledge graph is AST 0 。
Reestablishing a queue pool to be requested and a queue pool being requested through the request scheduling method to obtain a data set response updated by the depth knowledge graph of the medicine, and marking the data set response as the response 1 Converting the processed AST into AST 1 。
Step 3.3, comparing AST from the root node 0 And AST 1 Is a node of the network. The specific comparison method is as follows:
step 3.3.1, first, record AST 0 And AST 1 The traversing nodes in the tree are nodes respectively 0 And node 1 ；
Step 3.3.2, traverse from head to tail if node 0 And node 1 If the same, continue to compare down until AST 0 And AST 1 At least one party completes the traversal of all nodes. If node 0 And node 1 If the two types of the data are different, the traversal is directly ended;
and 3.3.3, based on the result of the last step, if nodes remain after the traversal is finished, sequentially comparing the traversal from the tail part forward. If node 0 And node 1 The same, the forward traversal continues. If node 0 And node 1 If the jump-out cycle is different, the jump-out cycle is completed.
Step 3.3.4, if AST 0 All nodes in the graph are compared and AST 1 There are also nodes that have not been compared. The nodes are newly added nodes, the client directly calls a new node DOM for creating a new node API in batches to generate a knowledge graph, and calls the API to mount the created nodes to the appointed node positions to realize rendering;
if AST 1 All nodes in the graph are compared and AST 0 There are also nodes that have not been compared. Then the client side directly calls the deleted node API in batches.
Conversely, when AST 0 And AST 1 The nodes in the tree are not compared, the rest nodes are defined as unknown child nodes, and the nodes are respectively marked as sum C 1 . The unknown child node is processed based on the longest incremental subsequence as follows. The specific algorithm is as follows:
step 3.4, establishing a two-dimensional mapping relation delta for the nodes in the pair, wherein the mapping relation delta is expressed as a subscript index pointing from the nodeId of the node to the set where the node is located, and the subscript index is expressed as follows:
the number of the nodes in the record is p, the number of the nodes to be processed in the record is q, and the number of the processed nodes is m. Initial value m=0.
Step 3.5, establishing a set L, wherein the elements are expressed as indexes of node elements in the set L. The initial value of the set L is 0, and the length is equal to q.
And 3.6, circularly traversing the nodes, marking the current traversed node as w, and determining the index of the old node in the new set according to the nodeId of w and the two-dimensional mapping relation delta. If no corresponding mapping result exists, index= -1 is recorded, which indicates that the node is removed in the updated knowledge graph, and the client calls the API to execute the node deleting operation. The index of the subscript of the old node in the new set is recorded into set L'. While increasing the value of m by 1. When m=p, the cycle ends.
And 3.7, traversing elements in the set L', and perfecting the set L through a mapping method. The mapping method specifically comprises the following steps: the traversal index is marked as i, the ith element in the L ' set is marked as n ', the nth element in the L ' set is filled, and the value is i+1. The formula is as follows:
and 3.8, obtaining the longest incremental subsequence of the set L. Denoted as L0. The nodes in L0 represent node indexes that do not need to be moved, and the true DOM of these nodes can be directly multiplexed in place. Therefore, the advantages of effectively multiplexing the original knowledge-graph real DOM and reducing the operation times of the knowledge-graph nodes are achieved, and the efficiency of rendering and updating the knowledge-graph during data updating is further improved. The algorithm for finding the longest incremental subsequence L0 is specifically as follows:
Step 3.8.1, creating a set R, defaulting to r= [ 0 ]. Set R represents the index storing the longest incremental subsequence.
In step 3.8.2, a precursor node set θ is created, and when a new value is newly added or replaced in the set R, the set θ is newly added with an item at the same time, where the item is an index of a previous item corresponding to the current item.
Step 3.8.3, node in traversal, denoted num. It is determined whether num is greater than the last element in set R. If so, the specification meets the longest incremental subsequence criteria, proceed to step 3.6.4; if not, step 3.6.5 is entered.
3.8.4, recording the current num at C by adopting dynamic programming thought 1 The corresponding index is j, i.e. C 1 [j]=num. Adding j to the set R, and simultaneously, recording the previous index of j in the set R into the set theta;
and 3.8.5, finding the first index larger than the current value by using a greedy algorithm idea and replacing the first index. The specific method comprises the following steps: defining the left index start and the right index end which are searched currently, judging whether the left index is smaller than the right index, if so, defining an intermediate value middle, wherein the intermediate value is expressed as that the intermediate value of the left index and the right index is rounded downwards, namely
. Judgment C 1 middle]Whether less than num. If yes, making the left index equal to the intermediate value index plus one; if not, let the right index equal the intermediate value. And searching according to the dichotomy until the left index is not smaller than the right index, and ending the dichotomy search. Replacing the corresponding value in set R with the current index, i.e. R [ start ] ]=j; simultaneously, the previous value of the corresponding value in the set R is saved into the set θ, namely R [ start-1 ]]Save to set θ.
Further, the traversal is ended. Since the greedy algorithm idea is applied in the replacement process in the previous step, backtracking correction is performed. And directly starting from the last bit, backtracking the set theta obtained before. The backtracking method specifically comprises the following steps:
the variables epsilon and eta are noted, the epsilon initial value is the length of the set R, and the eta initial value is the last value in the set R, namely eta = R [ epsilon-1 ]. The set θ is traversed in reverse order, epsilon subtracting one from epsilon, denoted epsilon=epsilon-1. Judging whether epsilon is larger than 0, if so, searching forward according to the precursor node, and correcting the value of the epsilon term in the set R to eta, namely R [ epsilon ] =eta; further, η is corrected to a value of η in the set θ, expressed as η=θ [ rε ]. If not, the backtracking is ended. At this time, the set R is the longest increment subsequence.
And 3.9, updating the knowledge graph according to the index set and the longest increment subsequence thereof.
Increasing in the position set can ensure that the node set C of the old knowledge graph 0 The order of the relative positions in the network, so that the knowledge graph can be updated without moving the nodes. Therefore, the longest increment of the subsequence can ensure that the moving times of the reusable nodes of the original knowledge graph are minimum. The temporal complexity of this algorithm is O (nlogn). The method has the advantages that when the medicine knowledge graph is updated, the child node real DOM of the old knowledge graph can be operated less by completing the comparison of the new node and the old node according to the method for updating and rendering the large data amount knowledge graph, so that the rendering and updating of the new medicine depth knowledge graph can be completed more quickly. The process of the method is shown in fig. 3.
The embodiment of the invention also provides a system for rendering and updating the depth knowledge graph of the medicine, which comprises the following modules:
request scheduling module: the system is used for managing network requests in the system, and large data of the medicine knowledge graph are requested in batches on the premise of the maximum parallel network requests which can be met by the client;
and a knowledge graph rendering module: the method comprises the steps that the method is used for rendering actual document object model nodes of the knowledge graph in the system, and the first mounting and rendering of the medicine depth knowledge graph are completed through function interface calling of the page element document object model in the script language; and when the data of the medicine nodes are updated, the updated medicine depth knowledge map is rendered through operations such as adding, deleting and moving the original knowledge map nodes.
And a knowledge graph updating module: and the method is used for comparing the data of the medicine knowledge maps before and after updating, calculating to obtain the minimum knowledge map change result, and further operating the child node document object model of the old knowledge map to finish the rendering of the new map.
Referring to fig. 4, the embodiment of the invention further provides a device for rendering and updating a drug depth knowledge graph, which further includes a memory and one or more processors, wherein executable codes are stored in the memory, and the one or more processors are used for implementing the method for rendering and updating the drug depth knowledge graph in the above embodiment when executing the executable codes.
The embodiment of the drug depth knowledge map rendering and updating device can be applied to any equipment with data processing capability, and the equipment with data processing capability can be equipment or a device such as a computer. The apparatus embodiments may be implemented by software, or may be implemented by hardware or a combination of hardware and software. Taking software implementation as an example, the device in a logic sense is formed by reading corresponding computer program instructions in a nonvolatile memory into a memory by a processor of any device with data processing capability. In terms of hardware, as shown in fig. 4, a hardware structure diagram of an apparatus with data processing capability where a device for rendering and updating a drug depth knowledge map according to the present invention is located is shown in fig. 4, and in addition to a processor, a memory, a network interface, and a nonvolatile memory shown in fig. 4, the apparatus with data processing capability in any embodiment generally includes other hardware according to an actual function of the apparatus with data processing capability, which is not described herein. The implementation process of the functions and roles of each unit in the above device is specifically shown in the implementation process of the corresponding steps in the above method, and will not be described herein again.
For the device embodiments, reference is made to the description of the method embodiments for the relevant points, since they essentially correspond to the method embodiments. The apparatus embodiments described above are merely illustrative, wherein the elements illustrated as separate elements may or may not be physically separate, and the elements shown as elements may or may not be physical elements, may be located in one place, or may be distributed over a plurality of network elements. Some or all of the modules may be selected according to actual needs to achieve the purposes of the present invention. Those of ordinary skill in the art will understand and implement the present invention without undue burden.
The embodiment of the invention also provides a computer readable storage medium, wherein a program is stored on the computer readable storage medium, and when the program is executed by a processor, the method for rendering and updating the medicine depth knowledge graph in the embodiment is realized.
The computer readable storage medium may be an internal storage unit, such as a hard disk or a memory, of any of the data processing enabled devices described in any of the previous embodiments. The computer readable storage medium may be any external storage device that has data processing capability, such as a plug-in hard disk, a Smart Media Card (SMC), an SD Card, a Flash memory Card (Flash Card), or the like, which are provided on the device. Further, the computer readable storage medium may include both internal storage units and external storage devices of any data processing device. The computer readable storage medium is used for storing the computer program and other programs and data required by the arbitrary data processing apparatus, and may also be used for temporarily storing data that has been output or is to be output.
The foregoing description of the preferred embodiments of the invention is not intended to be limiting, but rather is intended to cover all modifications, equivalents, or alternatives falling within the spirit and principles of the invention.
Claims (9)
1. A method for rendering and updating a medicine depth knowledge graph is characterized by comprising the following steps: the method comprises the following steps:
s1, managing a network request: on the premise of maximum parallel network requests met by a client, carrying out batch requests on big data of a medicine knowledge graph, wherein the batch requests comprise a to-be-requested pool queue and an on-request pool queue which are set according to graph node magnitude and experience value M of the client which initiates the network requests in parallel and does not cause blocking, the network requests are pressed into the to-be-requested pool queue, M requests are extracted from the to-be-requested pool queue and pressed into the on-request pool queue to carry out the network requests, all the requests are circularly sent, and the client obtains all network request results and stores the network request results in a knowledge graph node set;
s2, rendering actual document object model nodes of the drug knowledge graph, wherein the rendering method based on a browser request animation framework is adopted to perform step-by-step rendering on the block rendering of a large data volume according to the granularity of node groups in the drug knowledge graph, and the first mounting and rendering of the drug depth knowledge graph nodes are completed;
And S3, combining a greedy algorithm, dynamic programming and a backtracking algorithm, comparing the data of the drug knowledge maps before and after updating, calculating to obtain a minimum knowledge map change result, and further operating child nodes in a real document object model of the original knowledge map to finish the rendering of the new map.
2. The method for rendering and updating the depth knowledge graph of the medicine according to claim 1, wherein the method comprises the following steps: the specific substeps of the step S1 are as follows:
s11, calculating the node magnitude of the map, and calculating the request pool capacity according to the magnitude and the node group capacity requested by each client;
s12, initializing a to-be-requested pool queue and a requesting pool queue, wherein the capacity of the requesting pool queue is M, and M represents an experience value that a client side initiates network requests in parallel and does not cause blocking;
s13, initializing N network requests, and setting a monitoring event function for the network requests;
s14, pressing N network requests into a to-be-requested pool queue, and then taking out the first M requests from the to-be-requested pool queue according to the natural number from small to large arrangement order;
s15, the client initiates network connection to M requests in the request pool queue simultaneously and in parallel, and makes a network request, and after any one request in the request queue is successful, the request triggers a monitoring event function to issue a notification of successful request to the client;
S16, after receiving the notice of successful request, the client stores the network request result in the knowledge graph node set, and pops up the request from the request pool queue, and then takes the next request from the request pool queue to press into the request pool queue;
s17, repeating the steps S15 and S16 until all the requests are sent, and obtaining all the network request results by the client and storing the network request results in the knowledge graph node set.
3. The method for rendering and updating the depth knowledge graph of the medicine according to claim 1, wherein the method comprises the following steps: in the step S2, when the client draws the knowledge graph for the first time, the rendering method based on the browser request animation framework is adopted to perform batch optimized rendering, and the specific process is as follows:
s21, recording the node set to be rendered as the knowledge graph node set obtained in the step S1, wherein the node set to be rendered contains all node information in the knowledge graph to be rendered;
s22, setting a client refreshing frame rate;
s23, setting a callback function of a browser for rendering a knowledge graph by the client to request a rendering method of the animation framework;
s24, setting the calling time for triggering the callback function according to the refresh frame rate of the client;
and S25, circularly using a callback function, and rendering all the node sets to be rendered.
4. The method for rendering and updating the depth knowledge graph of the medicine according to claim 1, wherein the method comprises the following steps: in the step S3, when the data of the depth knowledge graph of the drug changes, the client draws the updated knowledge graph, and supplements, deletes or modifies the knowledge graph nodes based on the original knowledge graph, and the specific method is as follows:
s31, defining a data structure of an abstract syntax tree, wherein the data structure is composed of triples comprising an id of the node, a father node id corresponding to the node and a child node id set pointed by the node in a knowledge graph;
s32, processing the original knowledge graph node set to obtain an original abstract syntax tree of the converted knowledge graph; adopting a request scheduling method to obtain a new knowledge graph node set and an updated abstract syntax tree;
s33, circularly traversing the original abstract syntax tree and the updated abstract syntax tree, finding out the same head and tail of the original abstract syntax tree and the updated abstract syntax tree, performing traversing comparison, and obtaining the original abstract syntax treeThe remaining nodes of the grammar tree and the post-update abstract grammar tree which are not compared are respectively marked as C 0 And C 1 ；
S34, pair C 1 Establishing a mapping relation between the nodes, wherein the mapping relation is expressed as index of subscript pointing to the set where the node is located from the node identification of the node;
S35, establishing an index set, wherein the elements of the index set are expressed as C 1 The node element in C 0 Index of (a);
s36, traversing C 0 Determining index of index in new set according to node identification of node and mapping relation established above, establishing an initial index set for recording index of subscript of the old node in the new set;
s37, traversing the initial index set, and perfecting the index set through a mapping method;
s38, adopting a greedy algorithm, dynamic programming and a backtracking algorithm to obtain the longest incremental subsequence of the index set;
and S39, updating the knowledge graph according to the index set and the longest incremental subsequence thereof.
5. The method for rendering and updating the depth knowledge graph of the medicine according to claim 1, wherein the method comprises the following steps: the specific substeps of the step S33 are as follows:
s331: comparing all nodes of the original abstract syntax tree and the updated abstract syntax tree from the root node, and recording that traversing nodes in the original abstract syntax tree and the updated abstract syntax tree are respectively an original node identifier and a new node identifier;
s332: traversing from the head to the tail, if the original node identification is the same as the new node identification, continuing to compare downwards until at least one of the original abstract syntax tree and the updated abstract syntax tree completes traversing of all nodes, ending traversing, and entering step S334; if the original node identification is different from the new node identification, the traversal is directly ended, and the step S333 is entered;
S333: sequentially comparing forward from the tail until the traversal is different from the original node identification and the new node identification, ending the traversal, and entering step S334;
s334: if all the nodes in the original abstract syntax tree are compared, and the nodes which are not compared exist in the updated abstract syntax tree, the nodes are newly added nodes, a client calls a function interface for creating new nodes in batches to generate a new node document object model of a knowledge graph, and calls the function interface to mount the created nodes on the appointed node position to realize rendering;
if all the nodes in the updated abstract syntax tree are compared, and the nodes which are not compared exist in the original abstract syntax tree, the nodes are deleted nodes, and the client side calls function interfaces of the deleted nodes in batches;
if nodes in the original abstract syntax tree and the updated abstract syntax tree are not compared, defining the rest nodes as unknown child nodes, and respectively marking the unknown child nodes as C 0 And C 1 。
6. The method for rendering and updating the depth knowledge graph of the medicine according to claim 1, wherein the method comprises the following steps: the step S38 specifically includes:
s381: creating a sequence set representing the stored maximum increment sub-sequence index as the longest increment sub-sequence sought;
S382: creating a precursor node set, and when a new value is newly added or replaced in the sequence set, adding an item to the precursor node set at the same time, wherein the item is an index of a previous item corresponding to the current item;
s383: traversing the elements in the index set from the second element, marking the elements as num, and judging whether the num is larger than the value corresponding to the last element in the sequence set in the index set; if yes, go to step S384; if not, go to step S385;
s384: adopting a dynamic programming idea, marking the index corresponding to the current num in the index set as j, adding j into the sequence set, simultaneously, recording the previous index of j in the sequence set into the precursor node set, and enabling the sequence set to be the longest increment subsequence;
s385: adopting a greedy algorithm idea, finding a first index larger than the current value by using a dichotomy, replacing the index, replacing the corresponding value in the sequence set by using the current index, and storing the previous value of the corresponding value in the sequence set into a backtracking set; and then backtracking correction is carried out, starting from the last bit, backtracking is carried out on the backtracking set obtained in the front, and the longest incremental subsequence is obtained.
7. The method for rendering and updating the depth knowledge graph of the medicine according to claim 1, wherein the method comprises the following steps: the backtracking method in step S385 specifically includes: recording variables epsilon and eta, wherein the epsilon initial value is the length of the sequence set, and the eta initial value is the last value in the sequence set; traversing the precursor node set in a reverse order, and reducing epsilon by one; judging whether epsilon is not less than 0, if so, searching forwards according to the precursor node, correcting the value of the epsilon term in the sequence set to eta, and correcting the eta to eta in the precursor node set; if not, the backtracking is ended, and the sequence set is the longest increment subsequence.
8. The drug depth knowledge map rendering and updating system is characterized by comprising the following modules:
request scheduling module: the system is used for managing network requests in the system, and large data of the medicine knowledge graph are requested in batches on the premise of the maximum parallel network requests which can be met by the client;
and a knowledge graph rendering module: the method comprises the steps that the method is used for rendering actual document object model nodes of the knowledge graph in the system, and the first mounting and rendering of the medicine depth knowledge graph are completed through function interface calling of the page element document object model in the script language; when the data of the medicine nodes are updated, the updated medicine depth knowledge map is rendered through operations such as adding, deleting and moving the original knowledge map nodes;
and a knowledge graph updating module: and the method is used for comparing the data of the medicine knowledge maps before and after updating, calculating to obtain the minimum knowledge map change result, and further operating the child node document object model of the old knowledge map to finish the rendering of the new map.
9. A medicine depth knowledge map rendering and updating device is characterized in that: the apparatus comprises a memory and one or more processors, the memory having executable code stored therein, the one or more processors, when executing the executable code, for implementing the medication depth knowledge-graph rendering and updating method of any one of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211411193.0A CN116089748B (en) | 2022-11-11 | 2022-11-11 | Drug depth knowledge graph rendering and updating method, system and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211411193.0A CN116089748B (en) | 2022-11-11 | 2022-11-11 | Drug depth knowledge graph rendering and updating method, system and device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN116089748A true CN116089748A (en) | 2023-05-09 |
| CN116089748B CN116089748B (en) | 2023-08-08 |
Family
ID=86199847
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211411193.0A Active CN116089748B (en) | 2022-11-11 | 2022-11-11 | Drug depth knowledge graph rendering and updating method, system and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116089748B (en) |
Citations (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120260157A1 (en) * | 2011-04-11 | 2012-10-11 | Microsoft Corporation | Cooperative Rendering Cache for Mobile Browser |
| US20170308800A1 (en) * | 2016-04-26 | 2017-10-26 | Smokescreen Intelligence, LLC | Interchangeable Artificial Intelligence Perception Systems and Methods |
| CN110019823A (en) * | 2017-07-13 | 2019-07-16 | 阿里巴巴集团控股有限公司 | Update the method and device of knowledge mapping |
| CN110505511A (en) * | 2019-08-20 | 2019-11-26 | 海南车智易通信息技术有限公司 | It is a kind of to play the method, apparatus of video, system in webpage and calculate equipment |
| CN110647664A (en) * | 2019-09-23 | 2020-01-03 | 北京海致星图科技有限公司 | Method, system, medium and equipment for large-scale updating of tree graph in knowledge graph |
| CN110704630A (en) * | 2019-04-15 | 2020-01-17 | 中国石油大学(华东) | Self-optimization mechanism for identified associated graph |
| CN111258877A (en) * | 2018-11-30 | 2020-06-09 | 阿里巴巴集团控股有限公司 | Method and device for detecting visible time of first screen page and electronic equipment |
| CN111309897A (en) * | 2020-02-27 | 2020-06-19 | 中诚信征信有限公司 | Big data knowledge graph visualization method and device |
| CN113190773A (en) * | 2021-04-07 | 2021-07-30 | Oppo广东移动通信有限公司 | Rendering method of display data, electronic equipment, mobile terminal and storage medium |
| CN114595344A (en) * | 2022-05-09 | 2022-06-07 | 北京市农林科学院信息技术研究中心 | Crop variety management-oriented knowledge graph construction method and device |
-
2022
- 2022-11-11 CN CN202211411193.0A patent/CN116089748B/en active Active
Patent Citations (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120260157A1 (en) * | 2011-04-11 | 2012-10-11 | Microsoft Corporation | Cooperative Rendering Cache for Mobile Browser |
| US20170308800A1 (en) * | 2016-04-26 | 2017-10-26 | Smokescreen Intelligence, LLC | Interchangeable Artificial Intelligence Perception Systems and Methods |
| CN110019823A (en) * | 2017-07-13 | 2019-07-16 | 阿里巴巴集团控股有限公司 | Update the method and device of knowledge mapping |
| CN111258877A (en) * | 2018-11-30 | 2020-06-09 | 阿里巴巴集团控股有限公司 | Method and device for detecting visible time of first screen page and electronic equipment |
| CN110704630A (en) * | 2019-04-15 | 2020-01-17 | 中国石油大学(华东) | Self-optimization mechanism for identified associated graph |
| CN110505511A (en) * | 2019-08-20 | 2019-11-26 | 海南车智易通信息技术有限公司 | It is a kind of to play the method, apparatus of video, system in webpage and calculate equipment |
| CN110647664A (en) * | 2019-09-23 | 2020-01-03 | 北京海致星图科技有限公司 | Method, system, medium and equipment for large-scale updating of tree graph in knowledge graph |
| CN111309897A (en) * | 2020-02-27 | 2020-06-19 | 中诚信征信有限公司 | Big data knowledge graph visualization method and device |
| CN113190773A (en) * | 2021-04-07 | 2021-07-30 | Oppo广东移动通信有限公司 | Rendering method of display data, electronic equipment, mobile terminal and storage medium |
| CN114595344A (en) * | 2022-05-09 | 2022-06-07 | 北京市农林科学院信息技术研究中心 | Crop variety management-oriented knowledge graph construction method and device |
Non-Patent Citations (1)
| Title |
|---|
| 岳丽欣: ""基于交互式可视化的领域知识图谱构建研究"", 《情报科学》, vol. 38, no. 6, pages 145 - 150 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN116089748B (en) | 2023-08-08 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9678969B2 (en) | Metadata updating method and apparatus based on columnar storage in distributed file system, and host | |
| US8458727B2 (en) | Asynchronous client to server updates | |
| US9641468B2 (en) | Method, server, client, and system for releasing instant messaging key-value data | |
| CN111177161B (en) | Data processing method, device, computing equipment and storage medium | |
| CN112465046B (en) | Method, system, equipment and medium for artificial intelligence training of mass small files | |
| US8407713B2 (en) | Infrastructure of data summarization including light programs and helper steps | |
| CN111061739A (en) | Method and device for warehousing massive medical data, electronic equipment and storage medium | |
| US20200050476A1 (en) | Artificial Intelligence Chip And Instruction Execution Method For Artificial Intelligence Chip | |
| CN114329327A (en) | Sparse matrix parallel solving method and device based on upper and lower triangular decomposition | |
| CN103475905B (en) | The image data block efficient transmission method of connection multiplexing Network Based under cloud environment | |
| CN109799977B (en) | Method and system for developing and scheduling data by instruction program | |
| CN116089748B (en) | Drug depth knowledge graph rendering and updating method, system and device | |
| CN112988802A (en) | Relational database query optimization method and system based on reinforcement learning | |
| CN113918437A (en) | User behavior data analysis method and device, computer equipment and storage medium | |
| US20150186283A1 (en) | Smart Pre-Fetch for Sequential Access on BTree | |
| CN114328486A (en) | Data quality checking method and device based on model | |
| CN114064142A (en) | Batch-flow integrated data processing system and processing method | |
| Ma et al. | Developing a multi-GPU-enabled preconditioned GMRES with inexact triangular solves for block sparse matrices | |
| CN106776816A (en) | Locking method and device | |
| EP2821928A2 (en) | Method and system for limiting output results in a mobile telecommunication system | |
| CN113950145B (en) | Data processing method and device | |
| CN111901406B (en) | Front-end and back-end data real-time synchronization method for B/S architecture drawing modeling tool | |
| CN111538714B (en) | Instruction execution method and device, electronic equipment and storage medium | |
| CN110908993A (en) | Method and device for analyzing reasonability of database index | |
| CN115935946B (en) | Analytical mapping processing method and device for HL7V3 standard/FHIR standard |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |