KR20230037830A - Method and system for compressing graph stream based on incremental frequent patterns - Google Patents

Abstract

Disclosed are a method and system for compressing a graph stream based on incremental frequent patterns, which can improve the compression processing speed of a graph stream. The method for compressing a graph stream based on incremental frequent patterns according to an embodiment of the present invention comprises: a step of extracting a first subgraph from a sub-stream input for the first time in a graph stream according to a compression command for the graph stream input in real time; a step of storing the first subgraph in a pattern dictionary as an initial frequency pattern; a step of updating the first subgraph to an extension subgraph in the pattern dictionary and maintaining the same by using a second subgraph when the second subgraph different from the first subgraph is extracted from the sub-stream input for a second time after the first time has passed in the graph stream; and a step of compressing the extension subgraph, maintained in the pattern dictionary, as a reference frequency pattern when a time obtained by adding the first and second times reaches a determined time.

Description

Graph stream compression method and system based on progressive frequent patterns

The present invention relates to a method for compressing a graph stream, and more particularly, to improving compression efficiency of a graph stream using a gradual frequency pattern.

Graph data is being used to express complex connections such as social networks, the Internet of Things, mobile devices, and living things.

The graph data generated by these services is expanded and changed in real time, and the amount of information is huge.

Accordingly, a 'graph stream' representing irregular graph changes, such as adding, deleting, or changing vertices representing objects or edges representing relationships between objects, is generated in real time.

In order to efficiently store such a graph stream (graph data) that changes in real time in a limited in-memory, various graph mining techniques for compressing and storing the graph stream have been proposed.

However, there is a problem in that it is difficult to directly apply the previously proposed graph mining technology due to the high-dimensional and complex structure and shape of the graph stream.

According to graph mining algorithms such as 'StarZIP' (see Non-Patent Document 1) and 'GraphZIP' (See Non-Patent Document 2), which have been proposed as examples of structural graph compression techniques, the compression rate is high, but the structure of the graph (eg, Star , Clique, Bipartite….) takes a long time to perform, making it difficult to apply to an environment where data is generated in real time, and if the value to be converted becomes excessively large, the compression effect is lower than that of storing uncompressed data. .

In addition, in a graph mining algorithm such as 'GraphZip' (see Non-Patent Document 3) proposed as an example of an existing dictionary-based graph compression technique, a graph commonly appearing in vertices and edges is set as a reference pattern, and changes in the reference pattern are made. However, if the reference pattern increases beyond a certain size, it takes a long time to search for the reference pattern, and there are few or no reference patterns that can be applied when a new pattern completely different from the reference pattern is input. , the compression rate may decrease because the process of searching for the reference pattern again is required.

Therefore, a technique for increasing the compression efficiency of graph streams is required by applying graph mining in consideration of the graph stream environment in which vertices and edges change in real time over time in addition to the existing compression techniques that focus on compression rate and compression time.

[Non-Patent Document 1] B. Dolgorsuren, Khan K, Rasel MK, Lee Y “StarZIP: Streaming Graph Compression Technique for Data Archiving”, IEEE Access, pp.38020-38034, 2019 [Non-Patent Document 2] R. A. Rossi and R. Zhou, “GraphZIP: A clique-based sparse graph compression method” J. Big Data, vol. 5, no. 1, p. 1-14, 2018. [Non-Patent Document 3] P. Charles, and H. B. Lawrence, “GraphZip: Mining graph streams using dictionary-based compression,'' in Proc. SIGKDD Workshop Mining Learn. Graphs, 2017.

An object of the present invention is to propose a graph stream compression technique that compresses a graph stream in consideration of changes in vertices and edges over time in order to efficiently compress the graph stream.

An embodiment of the present invention finds a frequent pattern from a graph stream input in real time, maintains it in a pattern dictionary as a reference frequent pattern, and excludes infrequent patterns from the pattern dictionary to reduce data to be applied to graph stream compression. , the purpose of which is to increase the compression processing speed of graph streams.

In the embodiment of the present invention, when both patterns that are frequent in some graph streams input at the previous time and patterns that are frequent in some graph streams input at the current time are stored in the pattern dictionary, every time a new stream is input, the pattern dictionary In order to improve the existing graph mining technique, in which the size gradually increases and the compression efficiency of the graph stream decreases accordingly, the minimum standard frequent pattern frequently used throughout the graph stream that changes over time is left in the pattern dictionary, The purpose is to increase the compression efficiency of

An embodiment of the present invention repeats a process of expanding and updating a frequent pattern found at a previous time and stored in a pattern dictionary using a frequent pattern found at the current time, every time a stream is input over time, and frequently patterns in the pattern dictionary The purpose of this is to ensure that a frequent pattern, which is a reference, remains in the entire graph stream that changes with time in the pattern dictionary when a predetermined end point is reached by gradually updating .

A method for compressing a graph stream based on a gradual frequent pattern according to an embodiment of the present invention extracts a first subgraph from a substream input during a first time among the graph streams according to a compression command for the graph stream input in real time. and storing the first subgraph as an initial frequent pattern in a pattern dictionary, and a substream input during a second time from the lapse of the first time among the graph streams differs from the first subgraph in a pattern dictionary. If the second subgraph is extracted, updating and maintaining the first subgraph as an extended subgraph in the pattern dictionary using the second subgraph, and a sum of the first and second times. When the predetermined time is reached, compressing the extended subgraph maintained in the pattern dictionary as a reference frequent pattern may be included.

In addition, in the graph stream compression system based on the gradual recurrence pattern according to an embodiment of the present invention, according to a compression command for a graph stream input in real time, from a sub-stream input during a first time among the graph streams, a first sub-stream An extraction unit for extracting a graph; a storage unit for storing the first subgraph as an initial frequent pattern in a pattern dictionary; When a second subgraph different from the first subgraph is extracted from a substream, an update unit that updates and maintains the first subgraph as an extended subgraph within the pattern dictionary using the second subgraph; and and a processor that compresses the extended subgraph maintained in the pattern dictionary as a reference frequent pattern when the sum of the first and second times reaches a predetermined time.

According to the present invention, by finding a frequent pattern from a graph stream input in real time, maintaining it in a pattern dictionary as a reference frequent pattern, and excluding infrequent patterns from the pattern dictionary, reducing data to be applied to compression of the graph stream, The compression processing speed of the graph stream can be improved.

According to the progressive frequent pattern-based compression technique for graph stream processing proposed in the present invention, frequent patterns are extracted by graph pattern mining, pattern scores are calculated according to frequency and edge size, and frequent patterns are selected in order of high pattern scores. By leaving the pattern as a reference frequent pattern in the pattern dictionary, it is possible to detect a frequent pattern having a higher importance in a graph stream that changes in real time more quickly than conventional compression techniques, and it is possible to improve the compression efficiency and processing speed of the graph stream.

According to the present invention, changes in vertices and edges over time are recorded using provenance information so that a graph stream can be processed in an in-memory environment, and the provenance information is stored in a reference frequent pattern maintained in a pattern dictionary. is applied so that the manager can easily grasp the history of changes to the graph stream input in real time.

According to the present invention, by using the reference frequent pattern and provenance information, it is easy to manage the history of the latest pattern and grasp changes, and as a result, the size of graph data is reduced to maintain a lot of graph data in an in-memory environment. Allows for quick processing.

1 is a block diagram showing the configuration of a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
2 is a diagram showing the overall structure of a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
FIG. 3 is a diagram illustrating a process of performing the reference pattern generator 210 shown in FIG. 2 in the graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
4 is a diagram for explaining a process of assigning an index to a vertex of a subgraph and storing it in a pattern dictionary in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
FIG. 5 is a diagram illustrating a process of performing the graph manager 220 shown in FIG. 2 in the graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
6 is a diagram for explaining a process of determining an isomorphic graph according to a similarity determination result between subgraphs in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
7 is a diagram for explaining a time window that changes over time in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
8 is a diagram for explaining a process of gradually updating frequent patterns in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
9 is a diagram for explaining a pruning process to which the FP-Growth algorithm is applied in the graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
10 is a diagram illustrating a pattern dictionary (b) constructed according to a pattern tree (a) in a graph stream compression system based on progressively frequent patterns according to an embodiment of the present invention.
11 is a diagram illustrating provenance information stored in a pattern dictionary in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
12 is a diagram illustrating a compression process in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.
13 is a flowchart illustrating a sequence of a method for compressing a graph stream based on a gradual frequent pattern according to an embodiment of the present invention.

Hereinafter, embodiments will be described in detail with reference to the accompanying drawings. However, since various changes can be made to the embodiments, the scope of the patent application is not limited or limited by these embodiments. It should be understood that all changes, equivalents or substitutes to the embodiments are included within the scope of rights.

Terms used in the examples are used only for descriptive purposes and should not be construed as limiting. Singular expressions include plural expressions unless the context clearly dictates otherwise. In this specification, terms such as "include" or "have" are intended to designate that there is a feature, number, step, operation, component, part, or combination thereof described in the specification, but one or more other features It should be understood that the presence or addition of numbers, steps, operations, components, parts, or combinations thereof is not precluded.

Unless defined otherwise, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by a person of ordinary skill in the art to which the embodiment belongs. Terms such as those defined in commonly used dictionaries should be interpreted as having a meaning consistent with the meaning in the context of the related art, and unless explicitly defined in the present application, they should not be interpreted in an ideal or excessively formal meaning. don't

In addition, in the description with reference to the accompanying drawings, the same reference numerals are given to the same components regardless of reference numerals, and overlapping descriptions thereof will be omitted. In describing the embodiment, if it is determined that a detailed description of a related known technology may unnecessarily obscure the gist of the embodiment, the detailed description will be omitted.

In the present invention, according to the compression command for the graph stream, the input graph stream is gradually processed in real time, and a pattern dictionary that minimizes frequent patterns in the graph stream and provenance information thereof is constructed and applied to compression. By doing so, we propose a technique for increasing compression efficiency and improving processing speed.

To this end, in the present invention, a frequent pattern as a reference is gradually found in a graph stream that changes in real time, and a pattern dictionary is constructed to a minimum, and through this, data to be compressed can be reduced to a maximum.

As an example of gradually detecting a reference frequent pattern maximizing the compression ratio, in the present invention, a frequent pattern (initial frequent pattern) found at the beginning of the graph stream and pre-stored in the pattern dictionary is found at the next time of the graph stream. Isomorphism is checked by comparing with frequent patterns, and the frequent patterns with confirmed isomorphism are gradually expanded and updated, and after storing in the pattern dictionary, frequent patterns that have not been updated until the end of the graph stream are deleted, and the final As a result, the frequent patterns remaining in the pattern dictionary are detected as reference frequent patterns.

Here, the confirmation of isomorphism needs to be performed before proceeding with the update because the pattern at the present time and the pattern after the lapse of time may be different because the pattern of the graph stream does not always come out with a constant pattern but changes over time.

Therefore, in the present invention, when G ₁ is a subgraph of a frequent pattern previously stored in a pattern dictionary and G ₂ is a subgraph of a frequent pattern found at the next point in time, if G ₁ ⊆G ₂ , then G ₁ and G ₂ are isomorphic. It is possible to determine the graph and perform an update that expands G ₁ using G ₂ , so that the extended subgraph is maintained in the pattern dictionary.

As such, in the present invention, only frequent patterns that are frequently used in a graph stream that changes over time are left in the pattern dictionary, and infrequently used frequent patterns are deleted from the pattern dictionary, thereby gradually finding and compressing reference frequent patterns. By reducing the size of the pattern dictionary through , the compression efficiency of the graph stream can be increased, and the graph processing speed can be improved by maintaining a relatively large amount of data in in-memory.

1 is a block diagram showing the configuration of a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

Referring to FIG. 1, a graph stream compression system 100 based on progressive frequent patterns according to an embodiment of the present invention includes an extraction unit 110, a storage unit 120, an update unit 130, a processing unit 140, and a pattern dictionary 170. In addition, according to an embodiment, the graph stream compression system 100 based on progressive frequent patterns may be configured by adding a determination unit 150 and a calculation unit 160, respectively.

The extraction unit 110 extracts a first subgraph from a substream input during a first time T of the graphstream according to a compression command for the graphstream.

To this end, the extractor 110 applies the Time Window W _n shown in FIG. 7, which changes over time, to the graph stream input in real time, divides the graph stream into a plurality _of sub-streams, and divides the graph stream into a plurality of sub-streams. A first subgraph may be extracted from a first substream obtained by applying the first W ₀ to the graph stream.

As shown in FIG. 7, one W _n may be composed of several batches (B _n ), and when W ₀ ={B ₁ , B ₂ , B ₃ }, the extraction unit 110 performs a first sub A plurality of first subgraphs may be extracted from the stream.

The storage unit 120 stores the first subgraph as an initial frequent pattern in the pattern dictionary 170 .

For example, the storage unit 120 may store a plurality of vertices constituting the first subgraph and trunk lines connecting the plurality of vertices in the pattern dictionary 170 .

For example, referring to (a) of FIG. 8, the storage unit 120 uses W ₀ to form a plurality of vertices constituting the first subgraph extracted from the first stream and the trunk line connecting them to the pattern dictionary 170. can be stored in

When the first time T elapses, the extraction unit 110 extracts the first subgraph and the substream from the substream input during the second time T from the time point when the first time T elapses among the graph streams. A different second subgraph can be extracted.

Referring to (b) of FIG. 8 , the extraction unit 110 may extract the second subgraph from the second substream by applying W ₁ ={B ₄ , B ₅ } next to W ₀ to the graph stream. .

The update unit 130 updates and maintains the first subgraph as an extended subgraph in the pattern dictionary 170 using the second subgraph extracted by the extractor 110 .

That is, instead of simply storing the second subgraph extracted following the first subgraph in the pattern dictionary 170, the update unit 130 pre-stores the pattern dictionary 170 at the point of extraction of the second subgraph. Changes in vertices and edges constituting the second subgraph may be reflected in the pattern dictionary 170 through an update in which the first subgraph of is extended by the second subgraph.

For example, the update unit 130 divides the plurality of vertices constituting the second subgraph into existing vertices previously stored in the pattern dictionary 170 and new vertices not previously stored in the pattern dictionary 170. , A first trunk line connecting the existing vertex and the new vertex may be searched from the second subgraph.

Since the first trunk line does not exist in the first subgraph in the pattern dictionary 170, the update unit 130 additionally connects ('changes') the first trunk line to the first subgraph, Graphs can be updated with extended subgraphs.

In addition, the updater 130 may search for a second trunk connecting between the new vertices while being connected to the first trunk, from the second sub-stream.

Since the second trunk line is also an trunk line that does not exist in the first subgraph in the pattern dictionary 170, the updater 130 additionally connects ('inserts') the second trunk line to the first subgraph, An update to an extended subgraph can be performed. In this case, the update unit 130 may additionally connect the first subgraph even though the second trunk connecting the new vertices is not connected to the first trunk.

In addition, the update unit 130 may search for a third trunk line connecting the existing vertices from the second subgraph.

Since the third trunk line already exists in the first subgraph in the pattern dictionary 170, the update unit 130 does not add the third trunk line to the first subgraph, but corresponds to the corresponding section in the first subgraph. The frequency set in the trunk line can be increased.

Prior to performing the update, in order to check the isomorphism of the first subgraph and the second subgraph, the graph stream compression system 100 based on progressive frequent patterns may be configured by adding a determining unit 150. there is.

The determination unit 150 calculates the similarity between the first subgraph and the second subgraph using the 'VF2 algorithm' according to the extraction of the second subgraph, and according to the calculated similarity, the first subgraph It is determined whether the subgraph is an isomorphic graph that matches at least a part of the second subgraph.

For example, referring to (a) and (b) of FIG. 6 , the determination unit 150 determines graph G only when G ₁ =G ₂ when an existing subgraph pattern G ₁ and a newly entered subgraph pattern G ₂ exist. ₁ and G ₂ are not determined as isomorphic graphs, but graphs G ₁ and G ₂ having a relationship of G ₁ ⊆G ₂ are determined as isomorphic graphs, and G ₁ and G ₂ can be judged as patterns with high similarity .

When the first subgraph is determined to be an isomorphic graph of the second subgraph, the updater 130 may update the first subgraph using the second subgraph.

As such, the update unit 130 performs an update only when the pre-stored first subgraph is determined to be an isomorphic graph of the second subgraph extracted this time, and gradually detects frequent patterns in the graph stream input in real time.

Depending on the embodiment, the update unit 130 determines the frequency of the extended subgraph according to a value obtained by increasing the frequency set in the first subgraph before the update by the number of second subgraphs used for the update. can be set.

When the sum of the first time and the second time (2T) reaches a predetermined time (2T=τ), the processing unit 140 converts the extended subgraph maintained in the pattern dictionary 170 to a standard. Compression processing is performed as a frequent pattern.

At this time, when a plurality of first subgraphs are stored in the pattern dictionary 170 as the initial frequent pattern, the processing unit 140, among the plurality of first subgraphs, first subgraphs not involved in the update to the extended subgraph A graph may be deleted from the pattern dictionary 170 before the compression process.

In this way, the processing unit 140 retains frequently occurring patterns in the pattern dictionary 170 as reference frequent patterns and uses them for compression, and deletes infrequently occurring patterns from the pattern dictionary 170 to reduce the size of the pattern dictionary 170, It is possible to increase the compression efficiency of graph stream and reduce the time required for compression processing.

In another example, the processing unit 140 determines that the sum of the first time and the second time (2T) has not yet reached the predetermined time (τ) (2T<τ), and the sum of the times (2T) is determined. The compression process may be suspended until time τ is reached, and subgraph extraction by the extractor 110 and update by the update unit 130 may be repeated whenever a new substream is input from among the graph streams. .

That is, the extractor 110 extracts a third subgraph different from the first subgraph and the second subgraph from the substream input during the third time from the lapse of the second time, among the graph streams; The update unit 130 may update the extended subgraph into an additional extended subgraph using the third subgraph.

Through this process, the update unit 130 may gradually expand and update the first subgraph of the initial frequent pattern.

Even in this case, the processing unit 140 updates the extended subgraph or the additional extended subgraph among the plurality of first subgraphs when a plurality of first subgraphs are stored in the pattern dictionary 170 as an initial frequent pattern. The first subgraph not involved in can be deleted from the pattern dictionary 170 before the compression process.

As such, the processing unit 140 can maximize the compression ratio of the graph stream by maintaining frequently used patterns in the pattern dictionary 170 and deleting infrequently used patterns to reduce the pattern dictionary 170 .

In other words, in the present invention, the compression efficiency of the graph stream can be increased and the compression process can be performed quickly by leaving the minimum reference frequent pattern frequently used in the entire graph stream that changes with time in the pattern dictionary 170.

According to an embodiment, the graph stream compression system 100 based on gradual frequent patterns calculates pattern scores (RPS) so that patterns with higher importance are maintained in the pattern dictionary 170 as reference frequent patterns in consideration of the frequency and graph connectivity of the patterns. It can be configured by adding a calculator 160 that calculates.

If there are a plurality of extension subgraphs, the calculation unit 160 calculates pattern scores for each of the plurality of extension subgraphs by considering frequency and trunk size.

In order to adopt a subgraph pattern that occurs frequently throughout the graph stream and has many graph connections as a reference pattern, the calculation unit 160 considers the frequency and edge size of the subgraph pattern to obtain the formula described below. According to (1), the pattern score (RPS) can be calculated.

The processing unit 140 may select the top k (k is a natural number) extension subgraphs according to the pattern score order, and designate (select) the selected k extension subgraphs as reference frequent patterns.

At this time, the processing unit 140 may reduce the size of the pattern dictionary 170 by deleting the remaining extended subgraphs that are not selected from among the plurality of extended subgraphs according to the pattern score order from the pattern dictionary 170 .

For example, referring to FIG. 10, when a pattern tree as shown in (a) of FIG. 10 is input, each pattern is input to the pattern dictionary 230 as shown in the table 1010 shown in (b) of FIG. 10. Indexes 1 to 8 assigned in the order in which they are assigned are recorded as pattern identifiers P_id, timestamps for patterns P_id 1 to 4 are recorded as T, and timestamps for patterns P_id 5 to 8 are recorded as T+1. The frequency of the pattern is recorded.

Thereafter, the processing unit 140 applies Top-k (k=6), and when each pattern recorded in the table 1010 is sorted in order of frequency, the top 6 patterns P_id 1, 4, 2, 3, 8, and 5 are selected as reference patterns, and the remaining patterns that are not selected can be deleted.

When selecting the reference pattern, if the frequency of the patterns is the same, the processor 140 may preferentially select, as the reference pattern, a pattern having a greater number of edges or having a lower P_id due to being input first.

Accordingly, in the pattern dictionary 230, as shown in the table 1020 shown in (b) of FIG. 10, a reference frequent pattern that occurs frequently and has a large edge size and high graph connectivity can be maintained in the pattern dictionary 230.

In this way, in the present invention, by applying the Top-K Pattern, it is possible to select a reference pattern of high importance and keep it in the pattern dictionary 170, and also limit the Max-size of the pattern dictionary 170 to generate overload due to an increase in the amount of calculation. can prevent

The storage unit 120 may store, in the pattern dictionary 170, provenance information that records changes to the graph stream that is changed over time and input based on the extended subgraph designated as the reference frequent pattern. there is.

Here, the provenance information includes a pattern score calculated according to the set frequency and edge size for the extended subgraph designated as the reference frequent pattern, and each substream from which the first subgraph and the second subgraph are extracted. It may include at least one of timestamps recording the first and second input times, the number of batches constituting each substream, and a pattern ID for identifying the extended subgraph.

For example, referring to FIG. 11 , the storage unit 120 stores frequency, edge size, pattern score (RPS), timestamp, Prov (State), batch (Batch) for five patterns (pattern IDs 1 to 5). ) may be stored together in the pattern dictionary 170.

The processing unit 140 may perform compression processing by applying a dictionary encoding technique to the pattern dictionary 170 storing reference frequent patterns and provenance information therefor.

That is, when the processing unit 140 finds a repeating pattern in the data stream and builds a pattern dictionary 170 representing the repeating pattern with a shorter binary code, it can store compressed data using the binary code and the pattern dictionary 170. .

According to the dictionary-based compression technique in which the processing unit 140 finds a matching item between the set of strings contained in the data structure and the compressed text, and pre-encodes the graph into binary data, it is far more effective than storing the graph pattern as it is. It can be compressed and stored in a small size, so the memory space occupied can be greatly reduced.

According to the present invention, a process of expanding and updating a frequent pattern found at a previous time and stored in a pattern dictionary using a frequent pattern found at the present time is repeated every time a stream is input over time, so that a frequent pattern in the pattern dictionary is changed. By gradually updating, when a predetermined end point is reached, it is possible to ensure that a frequent pattern, which is the standard, remains in the entire graph stream that changes according to the change in time in advance of the pattern, and through this, the compression efficiency and processing speed of the graph stream can be improved. can

2 is a diagram showing the overall structure of a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

Referring to FIG. 2, the graph stream compression system 200 based on progressively frequent patterns according to an embodiment of the present invention includes a reference pattern generator 210, a graph manager 220, and a pattern dictionary 230 in the in-memory 201. ), and a compression processing unit 240.

The reference pattern generator (Reference Pattern) 210 extracts frequent subgraph patterns when the graph stream G[t] is input, calculates pattern scores according to the frequency and edge size of the extracted subgraph patterns, and extracts It plays a role in determining a certain number of reference patterns in the order in which pattern scores are calculated among the subgraph patterns.

Also, the reference pattern generator 210 may determine a pattern having the highest compression ratio among the extracted subgraph patterns as the reference pattern.

The reference pattern generator 210 repeats this process to transfer the reference pattern to the graph manager 220, and at the same time stores it in the pattern dictionary 230, so that it can be used in the next window.

The graph manager 220 manages patterns using a pattern management policy and determines similarities between patterns when there is a change in time in a stream environment.

In the pattern dictionary 230, subgraph patterns generated by the reference pattern generator 210 are stored together with related provenance information.

As shown in FIG. 11 , the provenance information may include a pattern ID, frequency, size of an edge, pattern score, timestamp, number of batches, and the like of each pattern.

All data stored in the pattern dictionary 230 is converted and stored by dictionary encoding in order to efficiently use storage space.

The reference pattern generator 210 and the graph manager 220 utilize data stored in the pattern dictionary 230 to determine a reference pattern.

The compression processing unit 240 finally compresses the graph data by applying the reference pattern created by the reference pattern generator 210 .

FIG. 3 is a diagram illustrating a process of performing the reference pattern generator 210 shown in FIG. 2 in the graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

Referring to FIG. 3 , the reference pattern generator 210 selects a pattern having the highest pattern score calculated through the processes of initial frequent pattern search (step 1), gradual frequent pattern search (step 2), and reference frequent pattern search (step 3). It can be determined as a standard pattern.

(Step 1) The initial frequent pattern search process is performed when a graph does not exist or there is no pattern in the pattern dictionary 230. In this case, the reference pattern stored in the pattern dictionary 230 does not exist. Thus, the reference pattern generator 210 searches the graph in batch size to initially find a single edge pattern.

[Table 1] shows an algorithm for searching for an initial frequent pattern. The edge e of the batch graph G _B is (v _source , v _target , l). The reference pattern generator 210 generates a single edge graph, modifies the vertices that come in front in the order of the list with v _source , and modifies the vertices that come later with v _target , and the edges are (v _source , v _target , l) After adding, it is stored in the pattern dictionary 230.

(step2) The gradual frequent pattern search process is repeatedly performed for the subgraph belonging to the pattern found in the graph, and is not performed during step 1 because the pattern does not exist.

[Table 2] shows the gradual recurrence pattern algorithm. In this process, a process of gradually updating the single edge pattern that appeared in the initial frequent pattern search is performed.

After checking each subgraph belonging to the set of subgraphs found in the graph and repeating G(v) → P(v), vertices are matched by index, and each subgraph is matched by index in the order in which vertices come in, resulting in a graph reduce the size of

4 is a diagram for explaining a process of assigning indexes to vertices of subgraphs and storing them in the pattern dictionary 230 in the graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

Referring to FIG. 4, when vertices are entered in order as in G(v) in the graph stream, P(v) is matched (assigned) to indexes (0, 1, ...) in the order of entry, and the pattern dictionary 230 ) is stored in That is, G(v)=[132, 12, 51, 43, 21, 19, 12, 3, ... comes in, P(v)=[0, 1, 2, 3, 4, 5, 1, 6, … in the order the vertices of the graph came in. matched with

At this time, as indicated by reference numeral 410, the vertex G(12) previously assigned to index '1' and the vertex G(3) assigned to index '6' are matched with existing indices (1, 6).

Connectivity is checked to see if the vertices stored in G(v) and P(v) are connected to the edges stored in the pattern, and if the value of G(v) is higher, the process of extending the pattern is performed.

For example, if the edge e of g(e) does not exist in the pattern, the pattern is expanded, and if present, it is added to the pattern dictionary 230.

(step 3) In the reference frequent pattern search process, a process of adopting a reference pattern according to pattern scores among the extracted subgraph patterns is performed.

In this process, in order to adopt a subgraph pattern that occurs frequently throughout the graph stream and has many graph connections as a reference pattern, the pattern score (RPS) is calculated according to Equation (1) in consideration of the frequency and edge size of the subgraph pattern, , the reference patterns may be adopted in the order of high pattern scores (RPS).

For example, if a pattern previously stored in the pattern dictionary 230 is determined to be an isomorphic graph with a subgraph g extracted from a newly entered graph G _B , the pattern score (RPS) calculated according to Equation (1) is the pattern dictionary ( 230) is updated. In Equation (1), α and β are constant values.

FIG. 5 is a diagram illustrating a process of performing the graph manager 220 shown in FIG. 2 in the graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

The graph manager 220 manages the pattern using the pattern management policy when there is a change over time in the newly entered graph stream G[t], and also determines the similarity of the graph, and if a pattern different from the existing one is found, the reference pattern It serves to rerun the generator 210.

Referring to FIG. 5 , the graph manager 220 includes a similarity verifier 221 and a pattern manager 222 to manage patterns by determining a pattern management policy according to the degree of similarity and importance of a new pattern with an existing pattern. It is composed by

The similarity verifier 221 compares existing patterns stored in the pattern dictionary 230 with a newly received pattern at time t to verify similarity.

The similarity verifier 221 may calculate the similarity according to the VF2 algorithm, and may also calculate the similarity between the reference pattern and the newly entered pattern G _t by performing a subgraph isomorphism test.

6 is a diagram for explaining a process of determining an isomorphic graph according to a similarity determination result between subgraphs in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

Referring to (a) and (b) of FIG. 6, the similarity verifier 221 calculates graphs G 1 and _G only when G ₁ =G ₂ when the existing subgraph pattern G ₁ and the new subgraph pattern G ₂ exist. ₂ is not determined as an isomorphic graph, but graphs G ₁ and G ₂ having a relationship of G ₁ ⊆G ₂ are determined as isomorphic graphs, and G ₁ and G ₂ can be determined as patterns with high similarity.

In most conventional compression algorithms, a method of determining a graph in which the reference pattern is common to vertices and edges is determined as a reference pattern and describing changes in the reference pattern, but if only patterns that match the graph pattern completely match are searched for, compression is performed. Considering the fact that it is difficult to apply compression because the number of patterns to be applied is small, the similarity verifier 221 can verify pattern similarity more flexibly than other algorithms by judging patterns that do not completely match as isomorphic.

The similarity verifier 221 determines the similarity between the reference pattern determined through the pattern score (RPS) and the newly entered pattern in the reference pattern generator 210 instead of the entire graph, thereby reducing the amount of comparison operation.

The pattern manager 222 determines and manages the importance of patterns through pruning using time-stamps and FP-trees, and limiting the size of patterns stored in the pattern dictionary 230.

Since a pattern does not always come out in a graph stream and the pattern changes over time, the pattern at the present time and the pattern after time may differ.

Considering this point, the pattern manager 222 applies timestamp trimming, pruning using FP-Tree, and Top-K Pattern policies when detecting frequent patterns.

Timestamp trimming is a process for securing a memory space for processing a graph stream to be input next by deleting a pattern after a window of a predetermined threshold value τ passes (see FIG. 7).

Pruning using FP-Tree is a process for efficiently using limited storage space by applying patterns stored in the pattern dictionary 230 to the FP-Growth algorithm and pruning (pruning) infrequent patterns ( see Figure 8).

The Top-K Pattern is a process for limiting the Max-size of patterns stored in the pattern dictionary 230 by storing only K patterns that frequently appear among the reference patterns (see FIG. 9).

Accordingly, patterns may be finally stored in the pattern dictionary 230 in order of high pattern scores normalized by combining the frequency, similarity, and importance of the patterns described above.

7 is a diagram for explaining a time window that changes over time in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

7 shows a time window W ₀ to W ₃ that changes over time, and a timestamp is updated whenever the time window elapses.

One window (W _n ) includes several batches (B _n ), and the number of batches can be designated by the user. For example, if a window W ₀ in which the number of batches is designated as '3' exists, W ₀ = {B ₁ , B ₂ , B ₃ }.

When the threshold τ=4 is set, the pattern manager 222 maintains the patterns W ₀ to W ₃ , and deletes the patterns W ₀ to W ₃ from the in-memory 201 before the pattern W ₄ is received. Thus, memory space for processing the next graph stream can be secured.

8 is a diagram for explaining a process of gradually updating frequent patterns in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

In (a) of FIG. 8, a pattern update in consideration of time is shown in the first stream, and in (b) of FIG. 8, a pattern update in consideration of time is shown in the second stream.

As shown in (a) and (b) of FIG. 8, the pattern manager 222 uses windows (W ₀ , W ₁ ) and batches (Batch 1 to 5) in the graph stream to change patterns over time ( The pattern dictionary 230 is managed by detecting changes in vertices and edges).

The reference patterns stored in the pattern dictionary 230 are managed by updating/deleting. For example, when a window with a batch size of 3 exists, as shown in (a) of FIG. 8, if all vertices are the first pattern, the timestamp is maintained at the current point, T.

When the size of the window is 3, the patterns P ₁ , P ₂ , and P ₃ appear in Batch 1, and P _{1 +} 2, the extended pattern of P ₁ and P ₂ , are added in Batch 2 to form P ₁ , P ₂ , P ₃ , and P _1+2, a total of 4 patterns appear. In Batch3, the patterns P ₂ , P ₃ , P ₁₊₂ , and P ₄ appear except for the P ₁ pattern from Batch 1 and Batch 2. Accordingly, patterns P ₁ , P ₂ , P ₃ , P ₁₊₂ , and P ₄ exist in W ₀ .

After that, the pattern is updated when the time changes from W ₀ → W ₁ as shown in (b) of FIG. 8 . If the _same pattern as W ₀ continues to appear in W ₁ , the _timestamp is maintained _at the current point in time (T). , correct the timestamp to T-1. The patterns P ₅ and P ₂₊₃ , which did not appear at the previous point but are added to the present, are added. By repeating this process, the timestamp is corrected, and patterns that do not appear in the window during the threshold value of T = τ are deleted.

In the present invention, through the process of updating/deleting patterns, frequently occurring patterns are maintained and used for compression, and infrequently occurring patterns are deleted and managed, thereby securing memory space and increasing the processing speed of graph streams.

9 is a diagram for explaining a pruning process to which the FP-Growth algorithm is applied in the graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

9 illustrates a pruning process to which the FP-Growth algorithm is applied. Information of (pid, B, T, Frequent) is stored in pattern P. Here, Pid is the pattern ID, B is the number of batches per window, T is the timestamp, and Frequent indicates the frequency.

When Frequent Threshold = 3 and Time Threshold = 2 are applied, patterns that occur below a certain threshold in leaf nodes are judged as infrequent patterns and pruned.

Patterns P ₁ and P ₁₊₂ that do not satisfy the threshold in window W ₀ are pruned.

Patterns P ₅ that do not satisfy the threshold in window W ₁ are also pruned.

Through this process, in the present invention, it is possible to reduce the cost of maintaining a pattern and create a memory space capable of holding data coming into the next stream.

Patterns stored in the pattern dictionary 230 are applied to the FP-Growth algorithm to pruning infrequently occurring patterns, thereby reducing the size of data to maintain and process a lot of graph data in an in-memory environment, and to perform infrequently used graph data. By updating/deleting patterns in the pattern dictionary, the latest patterns are maintained to improve compression efficiency in graph streams that change in real time.

10 is a diagram illustrating a pattern dictionary (b) constructed according to a pattern tree (a) in a graph stream compression system based on progressively frequent patterns according to an embodiment of the present invention.

Referring to FIG. 10 , when a pattern tree as shown in (a) of FIG. 10 exists, data may be stored in the pattern dictionary 230 in the form of tables 1010 and 1020 shown in (b) of FIG. 10 .

In the pattern tree shown in (a) of FIG. 10, first, patterns (0, 1), (0, 2), (1, 3), (2, 3) are input at time T, and the time elapses It shows that patterns (0, 1, 2), (0, 1, 3), (0, 2, 3), and (1, 3, 2) are input to T+1.

According to the pattern tree, in the table 1010, indexes 1 to 8 assigned in the order in which each pattern is input are recorded as pattern identifiers P_id, timestamps for patterns P_id 1 to 4 are T, patterns P_id 5 to 8 The timestamp for is recorded as T+1, and together with this, the frequency of each pattern is recorded.

When the time threshold τ is set to '2', a reference pattern is selected by applying Top-k to patterns input at times T and T+1 and recorded in the table 1010 .

When each pattern recorded in the table 1010 is sorted in order of frequency, if k is set to '6', patterns P_id 1, 4, 2, 3, 8, 5 corresponding to the top 6 frequencies The reference pattern is selected, the remaining patterns that are not selected are deleted, and finally the table 1020 can be stored in the pattern dictionary 230.

At this time, if the frequency (frequency) of the pattern is equal, a pattern with a greater number of edges is selected first, and if the number of edges is also equal, it can be determined to select the first input order, that is, in the order of lower P_id. .

As described above, in the present invention, by applying the Top-K Pattern, it is possible to select k patterns having a large edge size that occur frequently as reference patterns with high importance and store them in the pattern dictionary 230, and in addition, the Max-K patterns of the pattern dictionary 230 By limiting the size, it is possible to prevent overload caused by an increase in the amount of calculation.

The pattern dictionary 230 is stored in a space within the in-memory 201, and the reference pattern generated by the reference pattern generator 210 and related provenance information are stored in the pattern dictionary 230. The provenance information includes frequency, pattern ID, timestamp, pattern score, and the like.

For example, when a graph pattern is stored in the pattern dictionary 230, the frequency (frequency) is stored in the pattern dictionary 230 in consideration of how often vertices and edges of the graph pattern appear in the graph, and the pattern is identified. The available pattern ID, timestamp, pattern score, etc. are also stored in the pattern dictionary 230.

Using this provenance information, it is possible to easily grasp the change history of a graph stream that changes in real time from the reference pattern extracted by graph pattern mining.

In addition, all data stored in the pattern dictionary 230 is converted and stored by performing dictionary encoding. Afterwards, if the converted data is re-encoded, it has a smaller capacity than in the case of non-pre-encoding, enabling efficient use of memory space.

[Table 3] defines the elements of provenance information. Provenance information is displayed as Prov(Time, State), including the graph change time (Time, T _n ) and the graph vertex/trunk state (State). State is divided into insertion (I _n ), deletion (D _n ), and change (U _n ) of the vertex/trunk of the graph. According to [Table 3], provenance information of each pattern stored in the pattern dictionary 230 is illustrated in FIG. 11 .

11 is a diagram illustrating provenance information stored in a pattern dictionary in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

Referring to FIG. 11, when five patterns (pattern IDs 1 to 5) are stored in the pattern dictionary 230, the frequency, edge size, pattern score (RPS), timestamp, Prov (State), Provenance information generated including a batch may be stored in the pattern dictionary 230 together.

In the reference pattern generator 210 and the graph manager 220, by utilizing provenance information stored in the pattern dictionary 230, among the stored patterns, patterns with high graph connectivity, similarity, and high importance because they are frequent and have large edge sizes. may be selected as a reference pattern, patterns that are not selected may be deleted from the pattern dictionary 230, and finally only the reference pattern may be left in the pattern dictionary 230.

According to the present invention, by using the reference frequent pattern and provenance information, it is easy to manage the history of the latest pattern and grasp changes, and as a result, the size of graph data is reduced to maintain a lot of graph data in an in-memory environment. Allows for quick processing.

12 is a diagram illustrating a compression process in a graph stream compression system based on progressive frequent patterns according to an embodiment of the present invention.

Referring to FIG. 12 , the reference pattern generator 210 may gradually update an initial frequent pattern generated in a graph stream whenever a stream is input.

Then, when the time specified as the threshold value is reached, the reference pattern generator 210 utilizes the provenance information (frequency, edge size, pattern score, timestamp) obtained by the graph manager 220 to determine the frequency and importance. High patterns may be selected as reference frequent patterns, and patterns not selected may be deleted from the pattern dictionary 230 .

The compression processing unit 240 may compress the reference frequent patterns remaining in the pattern dictionary 230 using a dictionary-based compression technique.

The dictionary-based compression technique works by finding matching items between a set of strings contained in a data structure and compressed text.

That is, the compression processing unit 240 may find a repetition pattern in the data stream, build a dictionary representing the repetition pattern with a shorter binary code, and store compressed data using only the binary code and the dictionary.

As such, the compression processing unit 240 can significantly reduce the storage space to a much smaller size than storing the graph pattern by encoding the graph into binary data.

13 is a flowchart illustrating a sequence of a method for compressing a graph stream based on a gradual frequent pattern according to an embodiment of the present invention.

The graph stream compression method based on the gradual frequent pattern according to the present embodiment may be performed by the above-described graph stream compression system 100 based on the gradual frequent pattern.

Referring to FIG. 13, in step 1310, if a graph stream that changes in real time is input, in step 1310, the graph stream compression system 100, in step 1320, the first graph stream From the substream input during the time T, the first subgraph is extracted and stored as an initial frequent pattern in the pattern dictionary.

For example, the graph stream compression system 100 may store a plurality of vertices constituting the first subgraph and an edge connecting the plurality of vertices in the pattern dictionary.

In step 1330, the graphstream compression system 100 extracts a second subgraph different from the first subgraph from a substream input during a second time T following the first time T.

In step 1340, the graphstream compression system 100 expands and updates the first subgraph in the pattern dictionary by using the second subgraph.

For example, when the graph stream compression system 100 divides a plurality of vertices constituting the second subgraph into existing vertices previously stored in the pattern dictionary and new vertices not stored in the pattern dictionary, between the existing vertices and the new vertices. It is possible to perform an update to the extended subgraph by searching for a first trunk line connecting and a second trunk line connecting new vertices in the second subgraph and additionally connecting the first trunk line to the first subgraph.

In step 1350, the graphstream compression system 100 checks whether the sum of the first time and the second time (2T) reaches a predetermined time (τ).

If the predetermined time period (τ) is not reached, the graphstream compression system 100, from the lapse of the second time period (T) to the third time period (T) from the input sub-stream, the first and second sub-streams The process of extracting a third subgraph different from the graph and updating the extended subgraph into an additional extended subgraph using the third subgraph is the sum of the first time, the second time, and the third time. It is repeated until (3T) reaches a predetermined time (τ).

When the predetermined time τ is reached, in step 1360, the graphstream compression system 100 designates an extended subgraph in the pattern dictionary as a reference frequent pattern, and in step 1370, the graphstream compression system 100 , compresses the pattern dictionary.

As such, in the present invention, a frequent pattern is found from a graph stream input in real time, maintained in a pattern dictionary as a reference frequent pattern, and infrequent patterns are excluded from the pattern dictionary to reduce data to be applied to graph stream compression. As a result, the effect of improving the compression processing speed and compression efficiency of the graph stream can be obtained.

The method according to the embodiment may be implemented in the form of program instructions that can be executed through various computer means and recorded on a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. Program commands recorded on the medium may be specially designed and configured for the embodiment or may be known and usable to those skilled in computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks and magnetic tapes, optical media such as CD-ROMs and DVDs, and magnetic media such as floptical disks. - includes hardware devices specially configured to store and execute program instructions, such as magneto-optical media, and ROM, RAM, flash memory, and the like. Examples of program instructions include high-level language codes that can be executed by a computer using an interpreter, as well as machine language codes such as those produced by a compiler. The hardware devices described above may be configured to operate as one or more software modules to perform the operations of the embodiments, and vice versa.

Software may include a computer program, code, instructions, or a combination of one or more of the foregoing, which configures a processing device to operate as desired or processes independently or collectively. The device can be commanded. Software and/or data may be any tangible machine, component, physical device, virtual equipment, computer storage medium or device, intended to be interpreted by or provide instructions or data to a processing device. , or may be permanently or temporarily embodied in a transmitted signal wave. Software may be distributed on networked computer systems and stored or executed in a distributed manner. Software and data may be stored on one or more computer readable media.

As described above, although the embodiments have been described with limited drawings, those skilled in the art can apply various technical modifications and variations based on the above. For example, the described techniques may be performed in an order different from the method described, and/or components of the described system, structure, device, circuit, etc. may be combined or combined in a different form than the method described, or other components may be used. Or even if it is replaced or substituted by equivalents, appropriate results can be achieved.

Therefore, other implementations, other embodiments, and equivalents of the claims are within the scope of the following claims.

100: Graph stream compression system based on progressive frequent patterns
110: extraction unit
120: storage unit
130: update unit
140: processing unit
150: determination unit
160: calculation unit
170: pattern dictionary

Claims (15)

According to the compression command for the graph stream input in real time,
extracting a first sub-graph from a sub-stream input during a first time among the graph streams;
storing the first subgraph as an initial frequent pattern in a pattern dictionary;
Among the graph streams, if a second subgraph different from the first subgraph is extracted from a substream input during a second time from the lapse of the first time,
updating and maintaining the first subgraph as an extended subgraph within the pattern dictionary using the second subgraph; and
When the sum of the first and second times reaches a predetermined time,
Compressing the extended subgraph maintained in the pattern dictionary as a reference frequent pattern
Graph stream compression method based on gradual recurrence pattern including According to claim 1,
If the sum of the first and second times does not reach the predetermined time,
extracting a third subgraph different from the first and second subgraphs from a substream input during a third time from the lapse of the second time, among the graph streams; and
Updating the extended subgraph into an additional extended subgraph using the third subgraph
A graph stream compression method based on progressive frequent patterns further comprising. According to claim 2,
When a plurality of first subgraphs are stored in the pattern dictionary as the initial frequent pattern,
Deleting, from among the plurality of first subgraphs, a first subgraph not involved in updating to the extended subgraph or the additional extended subgraph from the pattern dictionary.
A graph stream compression method based on progressive frequent patterns further comprising. According to claim 1,
determining a degree of similarity between the first subgraph and the second subgraph using a VF2 algorithm according to the extraction of the second subgraph;
determining whether the first subgraph is an isomorphic graph that matches at least a part of the second subgraph according to the degree of similarity; and
When the first subgraph is determined to be an isomorphic graph of the second subgraph,
performing an update of the first subgraph by the second subgraph;
A graph stream compression method based on progressive frequent patterns further comprising. According to claim 1,
The step of storing the pattern dictionary,
Storing a plurality of vertices constituting the first subgraph and an edge connecting the plurality of vertices in the pattern dictionary
including,
The step of updating and maintaining,
dividing a plurality of vertices constituting the second subgraph into existing vertices stored in the pattern dictionary and new vertices not stored in the pattern dictionary;
searching for a first trunk line connecting the existing vertex and the new vertex from the second subgraph;
searching for a second trunk from the second sub-stream, which is connected to the first trunk and connects the new vertices; and
performing an update to the extended subgraph by additionally connecting the first trunk line and the second trunk line to the first subgraph;
Graph stream compression method based on gradual recurrence pattern including According to claim 1,
If the extended subgraph is plural,
Calculating a pattern score for each of the plurality of extended subgraphs by considering frequency and trunk line size;
selecting the top k (where k is a natural number) number of extended subgraphs according to the order of pattern scores; and
Designating the k extended subgraphs as the reference frequent pattern
A graph stream compression method based on progressive frequent patterns further comprising. According to claim 6,
Deleting an extension subgraph that is not selected among the plurality of extension subgraphs from the pattern dictionary
A graph stream compression method based on progressive frequent patterns further comprising. According to claim 1,
Storing, in the pattern dictionary, provenance information that records changes to the graph stream that is changed over time and input based on the extended subgraph designated as the reference frequent pattern.
Including more,
In the compression process,
compressing by applying a dictionary encoding technique to the pattern dictionary in which the reference frequent pattern and the provenance information are stored;
Graph stream compression method based on gradual recurrence pattern including According to claim 8,
The provenance information,
For the extended subgraph designated as the reference frequent pattern, the pattern score calculated according to the set frequency and trunk line size, and the time at which each substream from which the first and second subgraphs are extracted from the graph stream is input. At least one of a timestamp recording the first and second times, the number of batches constituting each substream, and a pattern ID for identifying the extended subgraph
A graph stream compression method based on progressive frequency patterns. According to the compression command for the graph stream input in real time,
an extraction unit extracting a first sub-graph from a sub-stream input during a first time among the graph streams;
a storage unit that stores the first subgraph as an initial frequent pattern in a pattern dictionary;
When a second subgraph different from the first subgraph is extracted from a substream input during a second time from the lapse of the first time, among the graph streams, by the extraction unit,
an update unit that updates and maintains the first subgraph as an extended subgraph in the pattern dictionary using the second subgraph; and
When the sum of the first and second times reaches a predetermined time,
A processing unit which compresses the extended subgraph held in the pattern dictionary as a reference frequent pattern.
A graph stream compression system based on progressive frequent patterns that includes. According to claim 10,
If the sum of the first and second times does not reach the predetermined time,
The extraction part,
Among the graph streams, a third subgraph different from the first and second subgraphs is extracted from a substream input during a third time period from the lapse of the second time period;
The update unit,
Updating the extended subgraph to an additional extended subgraph using the third subgraph
A graphstream compression system based on incremental recurrence patterns. According to claim 10,
According to the extraction of the second subgraph, a similarity between the first subgraph and the second subgraph is determined using a VF2 algorithm, and according to the similarity, the first subgraph is determined as the second subgraph. A discriminator for determining whether an isomorphic graph that matches at least a part of
Including more,
The update unit,
When the first subgraph is determined to be an isomorphic graph of the second subgraph,
Updating the first subgraph by the second subgraph
A graphstream compression system based on incremental recurrence patterns. According to claim 10,
If the extended subgraph is plural,
For each of the plurality of extended subgraphs, a calculation unit that calculates a pattern score by considering frequency and edge size.
Including more,
The processing unit,
Selecting the top k (k is a natural number) extension subgraphs according to the pattern score order, and designating the k extension subgraphs as the reference frequent pattern
A graphstream compression system based on incremental recurrence patterns. According to claim 10,
the storage unit,
Based on the extended subgraph designated as the reference frequent pattern, provenance information that records changes to the graph stream that is changed over time and input is stored in the pattern dictionary,
The processing unit,
Compressing by applying a dictionary encoding technique to the pattern dictionary storing the reference frequent pattern and the provenance information
A graphstream compression system based on incremental recurrence patterns. A computer-readable recording medium recording a program for executing the method of any one of claims 1 to 9.

Images