CN105808754A - Method for rapidly discovering accumulation mode from movement trajectory data - Google Patents

Abstract

The invention discloses a method for quickly discovering aggregation patterns from moving trajectory data, proposes the concept of aggregation, and proposes a closed group algorithm for discovery, an R-tree index technology, a grid index technology, a test division algorithm, and a TAD algorithm based on bit vector signatures , growth algorithm and a series of algorithms to efficiently discover aggregation from the trajectory and update it in time. Through the above method, the present invention provides a method for quickly discovering aggregation patterns from moving track data, which not only ensures the accuracy and accuracy of aggregation discovery, but also greatly improves the efficiency of data mining.

Description

A Method for Rapid Discovery of Aggregate Patterns from Movement Trajectory Data

technical field

The invention relates to the fields of database, data analysis, data mining, trajectory data analysis and trajectory data mining, in particular to a method for quickly discovering aggregation patterns from moving trajectory data.

Background technique

The increasing popularity of location acquisition technology makes it possible to collect a large number of trajectories of almost all moving objects. Discovering useful patterns from the behavior of these objects can deliver valuable information to various key applications. In this regard, we propose a new concept called gathering, which is a trajectory model that simulates various group activities, such as celebrations, military parades, protests, traffic jams, etc. Discovering aggregated patterns from trajectories presents two challenges:

(1) Define a suitable model:

First, previous work has always discerned dense regions by overlaying a fixed grid on geospatial space, but this may not match the actual shape of the assemblies in the aggregate. Although this problem can be solved to some extent by using grids with more appropriate spacing sizes, the resulting complexity increases exponentially. This makes this solution computationally infeasible.

The second, more essential problem is that previously the only criterion for judging a dense area was based on whether the number of individuals in one of the assemblies exceeded a given threshold, regardless of whether the individuals in the area shared a common behavior or not.

The concepts that have been proposed before are flock, convoy and swarm. But for flock, the circle does not reflect the real group in reality, which may lead to the so-called group loss problem; and both flock and convoy have strict requirements for the continuity of the time period; in addition, these three concepts are in survival It is necessary to include groups with the same set of individuals throughout the period. However, in a real group activity, such as commercial promotion, it is inevitable that members frequently join and leave activities, so this requirement is unrealistic.

And another concept: moving cluster (moving cluster) requires any two groups to share a sufficient number of the same individuals within a continuous time stamp, which is still difficult to satisfy in actual group activities. Furthermore, two persistent populations in a mobile cluster can be far apart, but an aggregation usually occurs in a relatively stable region.

(2) Efficient discovery algorithm

In previous work, the algorithm for finding flocks can only find groups in a fixed circular area; while the mobile cluster algorithm will repeatedly add a cluster at the next timestamp as long as it shares enough identical individuals with the current cluster; CuTS The algorithm first collects simplified trajectories to obtain the convoy participants, and then uses the moving cluster algorithm to get the correct result.

But none of the above algorithms are suitable for our problem, because we don't need any two consecutive clusters to share common objects.

Additionally, the object growth algorithm tries to enumerate all subsets of the object collection and checks if it is a swarm. In order to keep the computational complexity tractable, the algorithm proposes methods such as apriori pruning, backward pruning, and forward closure checking to effectively reduce the search space.

However, we can't borrow these techniques either, because the Aggregate pattern doesn't have the closed-down property.

Contents of the invention

The technical problem mainly solved by the present invention is to provide a method for quickly discovering aggregation patterns from moving track data, which has the advantages of high reliability and convenient search, and has broad market prospects in the application and popularization of small CNC machine tools.

In order to solve the problems of the technologies described above, a technical solution adopted in the present invention is:

Provide a method for quickly discovering aggregation patterns from mobile trajectory data, the steps include:

(1) Snapshot cluster stage:

Predefined aggregation: if and only if there are at least m _p participants in each snapshot cluster of a cluster Cr, i.e. , Cr is called a cluster, if there is no supergroup in a Cr and it is a cluster, then the cluster is said to be closed, where a snapshot cluster is a group of objects with arbitrary shape and size, crowd is a group, o is the trajectory of the moving object, t is the time threshold of the database

The time point in , o(t) is the position of the moving object o when the time is t, Par(Cr) is a set of participants of a group Cr;

Preset Definition 2: Given a moving object A collection of trajectories, supported by thresholds , variable threshold , and the lifetime threshold , a group Cr is the order of snapshot clusters within consecutive time stamps, ie , which meets the following requirements: Cr, the lifetime of Cr represented by _T is not less than ,Right now ; At any time there exists at least object, that is ;The distance between any two consecutive pairs of snapshot clusters is not greater than , ;

Since a snapshot set snapshotcluster is essentially a collection of points, given two point sets P and Q, the hausodrff distance between point sets P and Q defined as: ;

time threshold in the database At each time point of , the trajectories of moving objects are concentrated based on the density to find all the snapshot clusters. First, the original trajectories are simplified by the curve data compression algorithm, and then concentrated in the straight part. Each cluster of the straight part contains objects It is possible to form a snapshot cluster at some point in time, and output the database of the snapshot cluster ;

(2) The discovery phase of the group, that is, from Find all closed groups in :

(2.1) Definition Lemma 1: In the group in, if not present , such that if the group Cr is attached to will produce a new group, then the group Cr is a closed group, otherwise, the group Cr is not closed, among them, the cluster is the snapshot cluster when the time is t _i in the group Cr, the cluster is the snapshot cluster when the time is t _j in the group Cr;

(2.2) Use rangesearch, R-tree index cluster method or grid index cluster method to discover closed groups by attaching snapshot clusters to the current set of group participants V at the next point in time, group participants It is a collection of clusters that may grow into a group, which is equivalent to a candidate group;

The method of arranging index clusters RangeSearch: RangeSearch() is to find the distance from the cluster set at the current timestamp The Hausdorff distance is not greater than clusters, the implementation is to calculate each of , i.e. to calculate for each pair between the current crowd participant and the cluster at the current time point , find out from no greater than all clusters of

(3) Gathering and investigation stage:

Use the test partition algorithm TAD or the bit vector signature test partition algorithm to confirm whether each closed group obtained in the previous step is a closed aggregate or whether it contains a closed aggregate.

In a preferred embodiment of the present invention, the specific steps of finding a closed group by adding the snapshot cluster to the current set of group participants V at the next time point by using the method of arranging index clusters include:

Get the database of the snapshot cluster , preset the support threshold of a group , Preset the threshold of the lifetime of a group and the thresholds for the variables preset in the definition of the group ;

at each timestamp , check the last cluster of each group Cr, and judge whether the group Cr can be expanded by adding another cluster: to obtain the current timestamp, use the formula Calculate the set of clusters Each cluster in to cluster The Hausdorff distance, and find the distance from The Hausdorff distance is not greater than of clusters , where C is the set of clusters, is the set of clusters at the current timestamp, and is contained in ; if a cluster is found Then it can be extended, the extended group Insert as new participant after cluster participant V; if cluster not found That is, it cannot be extended, and when the lifetime of Cr is not less than , then according to Lemma 1, the group Cr is a closed group; if no cluster , and the lifetime of Cr is less than , then Cr is not a group; at any time stamp, a cluster R that cannot be attached to any existing group participant is treated as a new group participant.

In a preferred embodiment of the present invention, the specific steps of using the R-tree index cluster method to find a closed group by attaching the snapshot cluster to the current set of group participants V at the next time point include:

Get the database of the snapshot cluster , preset the support threshold of a group , Preset the threshold of the lifetime of a group and the thresholds for the variables preset in the definition of the group ;

use Represents a cluster The minimum rectangular boundary MBR, with the formula Represents the minimum distance between two rectangles, predefined Lemma 2: Given two clusters and , , c is a cluster in C;

Get the last cluster for each cluster Cr , For any cluster in the group Cr, use the formula Calculate the set of clusters Each cluster in to cluster Hausdorff distance;

use formula look up When the collection of clusters is retrieved And take out a set of participants, the set of participants is the same as The minimum distance is not greater than , and then refine these participants to find all , where the R tree is used to index the minimum rectangular boundary of the clusters in the set C of clusters, and a query window is established based on the R tree, and the window is a parameter of of To expand the MBR, the clusters contained in the node and not overlapping with the window are not participants;

Predefined Lemma 3: Let Represents the ath side of the rectangle M, a=(1, 2, 3, 4), defines the distance function for:

, then there is , that is, the calculated distance from Cr is less than A collection of snapshot clusters;

use formula Retrieve the participants in the R-tree, and then refine these participants to obtain the set of clusters satisfying Lemma 3, where the R-tree is used to index the MBRs of the clusters in C, and a query window is built based on the R-tree, which is The parameter is of Expand the MBR, by expand Each side of the so that it contains four rectangles, the rectangles are Indicates that a=(1, 2, 3, 4), in the traversal of the R tree, only when a node intersects with all four rectangles will the node be further checked;

Check the last cluster of each group participant to see if it can be extended by appending another cluster, if so, the expanded group participant is inserted as a new participant after the set V of group participants; if not, it cannot be extended , and the lifetime of Cr is not less than , then according to Lemma 1, the group Cr is a closed group; if it cannot be extended, and the lifetime of Cr is less than , then Cr is not a group; at any time stamp, a cluster R that cannot be attached to any existing group participant is treated as a new group participant.

In a preferred embodiment of the present invention, the specific steps of using the grid index cluster method to find a closed group by attaching the snapshot cluster to the current set of group participants V at the next time point include:

Get the database of the snapshot cluster , preset the support threshold of a group , Preset the threshold of the lifetime of a group and the thresholds for the variables preset in the definition of the group ;

Define the area of influence: For a cell located in row a and column b in a grid G , its area of influence is the same as The minimum distance is not greater than A collection of units, that is ;

First, divide the entire space of the group Cr into multiple units g with a grid G, and each unit has a side length equal to The square of , for each timestamp t, walk through the set of clusters After that, build a grid index with two data structures , the grid index contains a list of cells for each cluster in , where the list of cells Records the cells occupied by the cluster and each unit The reverse list of , which stores the clusters covered on this unit;

The area of influence of a cell consists of points in g at a distance no greater than points of , giving the last cluster of the group Cr as the query cluster and cluster The grid index of the next timestamp corresponding to the time ;

Pruning phase: from Select each unit g in and find where its cell list is the same as Intersecting clusters where only the covering Only the cluster of the influence area of each unit in the cluster can be the reference, otherwise there will be at least one disconnected cluster in the cluster distance ratio far point;

Refinement stage: Since the distance between any two points in the same unit must not be greater than , and in the limit, if ,same , so only the cells in different collections need to be examined , to find the distance in the set of clusters The Hausdorff distance is no greater than The clusters, that is, to retrieve each cluster in the group Cr, for any cluster in the group Cr , first add a set of units to and to get their common unit, for Point p in , calculate point p and The minimum Hausdorff distance of , and only need to calculate to point p and Hausdorff distance to points falling within the area of influence, express and The minimum Hausdorff distance between;

If found from The Hausdorff distance is no greater than of clusters Then it can be extended, the extended group Insert as new participant after cluster participant V; if cluster not found That is, it cannot be extended, and when the lifetime of Cr is not less than , then according to Lemma 1, the group Cr is a closed group.

In a preferred embodiment of the present invention, in the use of the test division algorithm, confirm whether each closed group obtained in the previous step is a closed aggregation or whether it is included in a closed aggregation:

Preset Definition 3: Given a group Cr object o is called a participant if and only if it appears in Cr at least In a snapshot cluster, let represents the collection of snapshot clusters in Cr containing object o, i.e. , then the participant of Cr is the collection of objects ;

Using the test division algorithm, start the test from the whole closed group, calculate whether it participates in activities for each snapshot cluster in the group Cr according to Definition 3 to judge whether it is a participant, and then check the participants in each cluster in the group number, each closed cluster is then tested according to the predefined clustering method to see if it is an aggregate; if not, invalid clusters are identified, which do not have enough participants, and the cluster is divided into several sub-columns by removing these clusters , where, for each subcolumn that is still a group, the test of whether the closed group is an aggregation is repeated again using the predefined aggregation method, until no further groups are found.

In a preferred embodiment of the present invention, the specific steps of using the bit vector signature test partition algorithm to confirm whether each closed group obtained in the previous step is a closed aggregation or whether it contains a closed aggregation include:

a) is the trajectory of each moving object of the group Cr Construct a bit vector signature BVS, and each BVS is a bit vector of length n, each bit of the vector represents the existence of o in the matching cluster, wherein, the BVS of all objects in the group Cr can be passed through the group Single-scan construction, and BVS only needs to be constructed once to be used in all recursive processes of TAD;

b) Test steps: use The BVS representing an object o, to test whether the group Cr is a closed group, is to calculate The number of digits in 1, that is, the Hamming weight of a bit vector, uses traversal The Hamming weight of the bit vector is obtained by means of all bits of the method or the counting method based on the binary tree mode. When using the counting method based on the binary tree mode, first get per the number of 1s in the bit, and then get every 4, ie The number of 1 in the bit, until the mth time, when 2 ^m = n, get the number of 1 in every n bit, any bit vector of n bits, its Hamming weight can be used The following steps are obtained, set the mask m, the mask m is a bit vector with the same length as the BVS; when the value of the Hamming weight is greater than or equal to , the closed group is a closed aggregate or contains a closed aggregate;

c) Division step: If a group is not aggregated, it is divided into a series of sub-columns, that is, the bit vector of the trajectory of each moving object is divided into a series of sub-vectors, extracted from the original BVS with a mask, and the mask and sub-group The same bit is 1, and the other bits are 0; by performing an "AND" operation on the original BVS and the mask, a new BVS is obtained, in which the bit of the desired subgroup remains 1 and the other bits are 0, so, Return a series of masks, and pass the mask into the test step of the subgroup, that is, the test step directly uses the mask to get the BVS of the object that matches the subgroup.

In a preferred embodiment of the present invention, the trajectories of moving objects should be periodically added to the database , the time domain is The database of trajectories of moving objects is , in the collected time domain as new trajectory and add to Later in the middle, the extended time domain is obtained , which corresponds to the updated database .

In a preferred embodiment of the present invention, after updating the database, the specific steps of finding the newly increased closed aggregation include:

1) Extension: Predefined Lemma 4: Lemma 4: Given a closed group in , if its last cluster is not in the most recent time point of ,in is the time for is a collection of clusters, then Cr is in is not scalable in , and Lemma 4 shows that only a part of groups or group participants in previous databases are scalable;

judge The middle cluster sequence is in Whether the set CS at the end can be expanded into new clusters whose sequence of clusters contains closed clusters in the previous database and cluster participants of length less than k;

After finding a closed group in step (2), save the group participants and the closed group at the end of the last timestamp, and then when a new set of trajectories is received and convert it to a clustered database After that, move the time cursor Set as , and change the current group participant from V to CS;

2) Aggregate update: Assume in a group has been expanded to A new closed group in , then find out When the closed aggregation in Use TAD algorithm or bit vector TAD algorithm;

Predefined Lemma 5: Use IC(Cr) to represent the set of invalid clusters in group Cr, then we have ,because The addition of new clusters in Some non-participants in may become participants, namely Aggregations in may expand either with Neighboring aggregation fusion in ; if found belongs to invalid cluster of , then all closures before tj gather at remains unchanged, that is, Theorem 2: When an invalid cluster is given ,in , then any closed aggregate exist remain closed in

Test steps: When using the bit vector TAD algorithm, first for Constructs a BVS for each moving object and detects invalid clusters;

After getting a series of invalid cluster ICs during the test phase, find out where the time stamp previous invalid clusters, i.e. , , and there is no make cluster , ,only The subgroups in need to be further examined because they contain new or updated aggregates.

The beneficial effect of the invention is that it not only ensures the accuracy and accuracy of aggregation discovery, but also can greatly improve the efficiency of data mining.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings that need to be used in the description of the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, other drawings can also be obtained based on these drawings without creative work, wherein:

Fig. 1 is an experimental effect diagram of dividing one day into three time periods in the method for quickly discovering aggregation patterns from moving track data;

Fig. 2 is described in the method for quickly discovering aggregation mode from moving track data

Experimental renderings divided by weather;

Figure 3 is about The described method of quickly discovering aggregation patterns from mobile trajectory data

Schematic diagram of the runtime of the method;

Figure 4 is about A method for quickly discovering aggregation patterns from mobile trajectory data

Schematic diagram of the running time of the method;

Figure 5 is about | A method for quickly discovering aggregated patterns from mobile trajectory data

Schematic diagram of the runtime of the method;

Figure 6 is about The described method of quickly discovering aggregation patterns from mobile trajectory data

Schematic diagram of the runtime of the method;

Figure 7 is about The described method of quickly discovering aggregation patterns from mobile trajectory data

Schematic diagram of the runtime of the method;

Figure 8 is about The described method of quickly discovering aggregation patterns from mobile trajectory data

Schematic diagram of the runtime of the method;

Figure 9 is a schematic diagram of the time cost comparison between the group expansion algorithm and the reconstruction method based on the database scale;

Fig. 10 is a schematic diagram of the time cost comparison between the group expansion algorithm and the reconstruction method.

detailed description

The following will clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only some of the embodiments of the present invention, rather than all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by persons of ordinary skill in the art without making creative efforts belong to the protection scope of the present invention.

Please refer to Fig. 1-10, the embodiment of the present invention includes:

(1) Propose the concept of aggregation: various extraordinary group events can be simulated.

The definition of aggregation: if and only if a group There are at least participants, that is , It's called gathering. if a There is no supergroup in and it is a set, then the set is said to be closed.

Aggregates have the following properties:

Scope: An aggregation usually involves a relatively large number of individuals.

Density: These individuals come from a dense population.

Persistence: Aggregation should last for a defined period of time without interruption.

Stability: The geometric properties (such as shape, position) of the population are relatively stable.

Commitment: At any time in an aggregate, there exist several dedicated members persisting for a period of time

Intervals (possibly discontinuously) persist in groups.

Preset Definition 1: Given a moving object A collection of trajectories, a distance threshold , and an integer m, the snapshot cluster SnapshotCluster at timestamp t is a non-empty subset satisfying the following conditions:

1) ,about and m, Leave is densely connected;

2) is the largest, that is, about and m and , and Leave is density-reachable;

A snapshot cluster is a group of objects with arbitrary shape and size. At a given time stamp, they are densely connected to each other. According to the concept of DBSCAN, such a snapshot cluster has the largest spatial size so that objects in which no two clusters with the same timestamp are overlapping, and abbreviate snapshotcluster to cluster and omit the parameter m, ;

Preset Definition 2: Given a moving object A collection of trajectories, supported by thresholds , variable threshold , and the lifetime threshold , a group is the order of snapshot clusters within consecutive timestamps, ie , which satisfies the following requirements:

1) Representative lifetime of not less than ,Right now ;

2) exists at least at any time object, that is ;

3) The distance between any two consecutive pairs of snapshot clusters is not greater than , ;

also, A subsequence of subsequence, called The sub-(super-)crowd, if It is said to be closed if there is no supergroup;

Since a snapshot set snapshotcluster is essentially a collection of points, given two point sets P and Q, the hausodrff distance between point sets P and Q defined as:

.

Default definition 3: Given a group , object is called a participant if and only if it appears in at least In a snapshot cluster, let represents the containing object of The collection of snapshot clusters in , namely ,but A participant is a collection of objects ;

(2) Propose multiple efficient algorithms:

Proposed a series of algorithm for discovering closed groups (Algorithm 1), R-tree index technology, grid index technology, Test-and-Divide Algorithm (TAD), TAD algorithm based on bit vector signature (TAD*), growth algorithm, etc. Algorithms to efficiently discover aggregates from trajectories and update them in time.

After obtaining the trajectories of a large number of moving objects, we analyzed the data and found some interesting information. Based on this information, we defined a new model—aggregation, and used it to simulate various group activities. First define a concept—crowd, which satisfies the first four attributes of aggregation (see point 4), and aggregation is a special group that satisfies the fifth attribute.

After the definition is given, closed aggregation can be found from a large amount of trajectory data according to the concept and characteristics of aggregation. To this end, we propose some new algorithms to speed up the discovery process. The discovery process is now divided into the following three stages:

Snapshot cluster phase:

exist At each time point of , object trajectories are clustered based on density to discover all clusters of snapshots. In order to reduce the cost, the Douglas-Peucker algorithm is used to simplify the original trajectory first, and then concentrate on the straight line. The objects contained in each cluster of the straight line part may form a snapshot cluster at some point in time. Discovering snapshot clusters in such a collection of objects is more efficient than directly in the entire collection of objects. The output of this process is the database of the snapshot cluster .

Group discovery phase:

This stage aims to start from Find all closed groups in .

It is easy to know that groups satisfy the downward closure property, that is, an arbitrarily long sublist of a group is still a group, which makes outputting all subgroups redundant. More importantly, there is no guarantee that an aggregate detected from an open swarm is closed. Therefore, at this stage we only find closed groups, not all of them. To find a closed group, the first thing that comes to mind is the need to examine each supersequence of the group to check whether it is closed. But actually, according to the following lemma, it is enough to check whether a group is closed by appending one more cluster of snapshots.

Lemma 1: Given a group , if not present , such that it satisfies if in add in will generate a new group, then is a closed group. otherwise, is not closed.

According to this lemma, closed groups can be discovered by appending the cluster of snapshots to the current set of group participants (denoted by V) at the next time point. This process is realized by Algorithm 1, and Algorithm 1 is as follows:

enter:

;//set of closed groups

;//The collection of current group participants

At each timestamp, the last cluster of each swarm participant is checked to see if it can be expanded by appending another cluster. If applicable, the extended group participant is inserted after V as a new participant. Otherwise, according to Lemma 1, we can conclude that it is also a closed group (if the length is not less than k _c ), or it is not a group. Note that at any time-stamp, a cluster (denoted by R) that cannot be attached to any existing swarm participant should also be considered a new participant, since it may later grow into a swarm.

Obviously, the RangeSearch() process in Algorithm 1 is time-consuming. RangeSearch() is at the current timestamp, from the collection of clusters search from The Hausdorff distance is not greater than of clusters. A naive implementation of this is to just compute each of . Obviously, only the calculation The time complexity of . Also, to compute the pairwise . This makes the computation expensive for large databases. To solve this problem, we invented spatial index technology to organize clusters and speed up the finding process.

R-tree index clusters: We really don't need the exact Hausdorff distance between two clusters, but we just need to know

Whether their distance is greater or less than Will suffice. use Represents the minimum holding boundary (MBR, minimumboundingrectangle) of cluster c, with Indicates the minimum distance between two rectangles. Then we have the following Lemma 2:

Lemma 2: Given two clusters and , .

Based on this lemma, we first retrieve and fetches a set of actors that is the same as The minimum distance is not greater than , and then refine these participants to get the final result. In order to perform participant search more efficiently, we use R-tree to index the MBRs of clusters in C, and build a query window based on R-tree, which is a parameter of of Expand the MBR. Clearly, clusters contained in nodes that do not overlap the window are not participants.

However, is a rather vague low-level bound on the Hausdorff distance. The following lemma provides a tight low-level bound on the Hausdorff distance.

Lemma 3: Let Represents the a-th side of the rectangle M (a=1,2,3,4). Define the distance function for:

.

use To retrieve participants in the R-tree, we need to make some slight modifications to the window query process mentioned earlier, as follows: first pass expand Each side of the so that it contains four rectangles, the rectangles are Indicates that a=1, 2, 3, 4. In the traversal of the R-tree, a node is checked further only if it intersects all four rectangles.

Grid index cluster: Although the R-tree index cluster eliminates many unqualified nodes and improves the performance of the discovery process, it still has three disadvantages:

a) The R tree must be constructed or maintained at each time point, which may cause a high cost;

b) Due to the arbitrary shape of the density-based clusters, the rectangular bounding box cannot always obtain the distribution of points in the clusters, which will affect the pruning effect.

c) Violent refinement still requires estimating the Hausdorff distances for these participant clusters.

To address these issues, we propose a grid-based index for clusters. As we will see shortly, grid indexes are easier to construct since clusters of individual timestamps can share the same grid structure. Grid units allow for more efficient pruning and are closer to cluster shapes. In addition, a better improved algorithm can be devised with grid indexing, and the algorithm can confirm whether it is a participant without calculating the exact Hausdorff distance.

First, we use a grid to divide the entire space, where each cell has an edge length equal to of squares. For each time point t, after browsing the cluster collection, a grid index can be built with two data structures , called each cluster A list of cells, which records the cells occupied by the cluster and each cell An inverted list of , which stores the clusters overlaid on this cell. Before describing this algorithm, first define the influence region of a unit (affectregion).

Definition 1 (influence area): Given a cell in row a and column b in grid G , its area of influence is the same as The minimum distance is not greater than A collection of units. more specifically, .

Intuitively, the region of influence of a cell may contain some points at distances from g not greater than point. Now, given querycluster (i.e., the last cluster of some crowd participants) and the grid index for the next timestamp , the procedure RangeSearch() of Algorithm 1 works in a pruning and refinement manner, as follows:

In the pruning phase, we start with Select each unit g in and find where its cell list is the same as intersecting clusters. Easy to know, only cover Only the cluster of the area of influence of each unit in can be the reference, because otherwise there will be at least one disconnected distance ratio far away.

In the elaboration phase, we will confirm each participant to decide the final result. for participants , we first add a set to and to get their common unit. The latter principle is the distance between any two points in the same unit, and it is not greater than . A limiting case is if , we can immediately conclude that . Therefore, we only need to check the cells that are in different sets, i.e. . for Point p in , without loss of generality, we calculate its and the minimum distance. Note that we only need to calculate the distance between point p and points that fall within the influence area, because all other points must have a distance from p greater than .

(3) Gathering and investigation stage:

This stage will confirm whether each closed group obtained in the previous step is or contains a closed aggregation. This phase proposes the following algorithms:

Test-and-Divide Algorithm (TAD): It can efficiently detect all closed aggregations in a given group, as follows:

Algorithm 2 starts from the whole closed group to test whether it is an aggregate. If it is, as demonstrated, it is a closed aggregate and can be returned immediately as a result. Otherwise, we identify invalid clusters, which do not have enough participants, and divide the group into several subsequences by removing these clusters (some subsequences have length less than k and thus may not be cliques). For each sub-column that is still a cluster, we repeat the above steps again because some objects may become non-participants at this time due to the removal of invalid clusters. This process is performed recursively until no more groups are found.

Efficient implementation with bit vector signatures: A straightforward implementation of the TAD algorithm is to count its occurrences for each object in the swarm to determine if it is a participant, and then check the number of participants in each cluster in the swarm. Obviously, the time complexity of doing this is , where m is The number of objects in . Even worse, we have to repeat the above operation for each of the preliminary get.

In order to make TAD have a more efficient implementation, we provide Each object constructs a bit vector signature (bitvector signature, BVS), and all subsequent steps can be implemented with faster bit operators. In particular, given a group , each of whose objects The BVS is a bit vector of length n, and each bit of the vector represents the presence or absence of o in the matching cluster. BVSs for all objects in can be constructed from a single scan of the group. More importantly, BVSs only need to be constructed once to be used in all recursive processes of TAD.

Next, we will elaborate on how to implement the algorithm in Algorithm 2 by optimizing the BVS and process.

a) Test steps. use A BVS representing an object o, The process is essentially computing The number of bits of 1 in the middle, that is, the Hamming weight of a bit vector (Hammingweight). The easy way is to traverse , but we use more efficient ways, where the best solution is counting based on binary tree patterns. Thus, we first get The number of 1s in each 2-bit slice of , then the number of 1s in each 4-bit slice, ..., and so on. The following example shows that it takes only three steps to get The process of the Hamming weights.

make ,

let m1=01010101,

Let m2=00110011,

Let m4=00001111,

Now the decimal number of x is 4, which is exactly equal to The number of digits in 1. In the above operations, m1, m2, m4 are also called masks and can be defined more appropriately once the bit vector is known. In general, for any n-bit bit vector, its Hamming weight can be obtained in steps within log2(n).

b) Division steps. In this step, if a group has not become aggregated, we will divide it into a series of sub-columns. Essentially, each object's vector is divided into a series of sub-vectors. But it is worth mentioning that it is not necessary to operate on non-participant BVSs, because a non-participant group must maintain any of its subgroups with non-participants. At the same time, it is not necessary to physically divide the BVS, instead, only the mask can be used to extract the desired part from the original BVS. The mask is also a bit vector of the same length as the BVS. The same bit as the subgroup is set to 1, and the other bits are set to 0. By ANDing the original BVS and the mask, a new BVS can be obtained in which the desired subgroup's location bit remains 1 and the other bits are 0. so, Just need to return a series of masks, smaller than the sub-column of the returned group, and pass it into the sub-column's process. By this method, The process can directly use the mask to get the BVSs of the objects that match the subgroups, which can avoid the reconstruction of the BVSs of each subgroup.

In real-world applications, trajectories are often received gradually. In this way, the latest batch of trajectory data should be periodically (e.g., daily, weekly or monthly) added to the database. In particular, consider the time domain as trajectory database . In the collected time domain as A batch of new trajectories for and add to After middle, we get the extended time domain , which corresponds to the updated database .

A big challenge with this gradual update is that closed groups found in the pre-update database may not be closed after the update because they may be Cluster expansion in . Therefore, if the resident group in a closed aggregate is expanded, the aggregate may also change. In order to get correct results over time, a simple solution is to directly use the previously mentioned technique to find the time domain Corresponding aggregation of the entire database. Obviously, as the size of the database increases, the cost of this method is also increasing, and it is ultimately unbearable. To address this, we propose an incremental algorithm for efficiently generating new closed aggregates that takes advantage of groups and aggregates already found in previous databases.

1) Expansion. First, Lemma 4 shows that only a fraction of groups (or group participants) in previous databases are scalable.

Lemma 4: Given a closed group in , if its last cluster is not in the most recent time point of ,in is the time for is a collection of clusters, then exist Not scalable.

Based on this lemma, we only need to consider The middle cluster sequence is in Set CS at the end of time to see if they can be expanded into new groups. These cluster sequences contain closed groups and group participants (still less than k in length) from previous databases. To this end, we slightly modify Algorithm 1 so that the others save the group participants and closed groups whose last timestamp ends. Then, upon receiving a new set of trajectories and after converting it to a database of clusters, i.e. . Make the following modifications to the process of Algorithm 1: Modify the time cursor Set as , and change the current group participant from V to CS.

2) Aggregate update: Assume in a group has been expanded to A new closed group in . The goal now is to find out Closed aggregates in . The general practice is to again Use the TAD algorithm. But some aggregates are as early as has already been detected in , and using it more judiciously can speed up the discovery process. when Take up This optimization can bring additional benefits when a large portion of . As we said before, we start with Construct the BVS for each object, then run Procedure to detect invalid clusters. The next lemma shows that Some invalid clusters in can become effective.

Lemma 5: Use representative group The collection of invalid clusters in . then there is . because The addition of new clusters in Some non-participants in may become participants. In other words, Aggregations in may expand either with Aggregation and fusion of neighbors. However, if we find Some invalid clusters in , they also belong to , it can be guaranteed that the All previous closures gather at remain unchanged. More precisely, we have the following theorem:

Theorem 2: Given an invalid cluster ,in , then any closed aggregate exist remains closed.

According to Algorithm 2, we can optimize The clustering discovery process improves the original TAD algorithm. After getting a series of invalid cluster ICs during the test phase, we find out the previous invalid clusters, i.e. , and there is no make . Theorem 2 ensures that The closed aggregation in is the same as before. Therefore only The subgroups in need to be further examined because they contain new or updated aggregates.

According to the actual situation, rational use of the above algorithm can find out all closed aggregations in the trajectory database, and the latest results can be calculated efficiently after each update of the database.

The aggregation model proposed by the present invention overcomes the shortcoming of including the same individual during the lifetime in the group model, that is, members can join and leave the aggregation at any time.

At the same time, we have done a lot of experiments based on the real trajectory database to verify the effectiveness and efficiency of the proposed concepts and algorithms. The experimental data contains monthly 120K trajectories generated by more than 33,000 taxis in Beijing within 3 months (March, April, and May 2009). In addition, the interval unit of the time domain is minutes, and the 132480 time points (60*24*92) in the middle. The experimental results are as follows:

(1) Effectiveness

Divide a day into three time periods: peak hours (6:00 am--10:00 am and 5:00-8:00 pm), working hours (10:00 am--5:00 pm), and rest periods (8:00 pm - 5:00 am). Figure 1 shows the average number of crowds (groups), gatherings (gathering), swarms and convoys in these three time periods of the day. As can be seen:

1) The peak hours gather the most, and other time periods are less;

2) Although there are many swarms during breaks, only a small portion turns into swarms;

3) There are more swarms and convoys during peak hours and off hours than working hours.

According to the weather conditions, all 92 days are divided into three groups: sunny days, rainy days, and snowy days. The experimental results are shown in Figure 2:

1) The accumulation is the least in sunny days and the most in snowy days;

2) There is a large gap between the number of groups and gatherings in snowy days;

3) The number of swarms is not sensitive to weather changes, but the number of convoys is the least in snowy days.

(2) Efficiency

The performance of the group discovery algorithm:

Compare three of these pruning calls: a) SR, a simple R-tree based pruning (with ); b) IR, an improved pruning-based R-tree (with ); c) GRID, grid-based pruning. The experimental results are as follows:

1) From the overall view of Figure 3/4/5, IR significantly improves the pruning effect of SR, and GRID further improves the performance of IR, and the performance is at least an order of magnitude better than SR;

2) As can be seen from Figure 3, with Increasing, the time cost of all algorithms is decreasing;

3) As can be seen from Figure 4, with Increase, the performance of all algorithms is getting worse;

4) It can be seen from Figure 5 that as the database size increases, the time required for all algorithms also increases, but the grid-based pruning is the least sensitive to the database size.

The performance of the aggregation scouting algorithm:

Three algorithms used for reconnaissance aggregation are compared: a) brute force method; b) TAD algorithm; c) TAD*: TAD algorithm implemented with bit vector signature. The experimental results are as follows:

1) From Figure 6/7/8, it is easy to know that the performance of TAD is one to two orders of magnitude better than the brute force method, and the TAD* algorithm improves the performance of the TAD algorithm by 30%;

2) It can be seen from Figure 6 that with increases, the time cost of the brute force method increases significantly, while TAD and TAD* first increase slowly and then decrease;

3) It can be seen from Figure 7 that with The time cost of the brute force method increases significantly, while TAD and TAD* first increase slowly and then decrease;

4) It can be seen from Figure 8 that with increases, the time cost of the brute force method increases almost exponentially, and the performance of TAD and TAD* is also getting worse, but the change is small, while When larger, TAD* showed more benefit.

Performance of the growth algorithm:

The experimental results are as follows:

1) It can be seen from Figure 9 that the time cost |T _DB | of the reconstruction method increases with the expansion of the time domain. It can be predicted that as the database scale continues to grow, the cost of the reconstruction method will eventually be very large, and the The time spent by the extended algorithm is almost constant;

2) It can be seen from Figure 10 that the change of the variable r does not affect the reconstruction method, but with the increase of r, the efficiency of the aggregation update algorithm is higher, and r refers to the share of the previous group in the updated group red Ratio, according to the size of r, calculate the running time of the two algorithms respectively, the group expansion algorithm does not depend on r, but r will affect its running time;

3) We also experimented with other parameters in Figure 2 and Figure 3, and the experimental results are similar.

The above descriptions are only examples of the present invention, and are not intended to limit the patent scope of the present invention. Any equivalent structure or equivalent process transformation made by using the content of the description of the present invention, or directly or indirectly used in other related technical fields, shall be The same reasoning is included in the patent protection scope of the present invention.

Claims (8)

1. A method for quickly discovering aggregation patterns from moving track data, characterized in that the steps include: (1) Snapshot cluster stage: Predefined aggregation: if and only if there are at least m _p participants in each snapshot cluster of a cluster Cr, i.e. , Cr is called a cluster, if there is no supergroup in a Cr and it is a cluster, then the cluster is said to be closed, where a snapshot cluster is a group of objects with arbitrary shape and size, crowd is a group, o is the trajectory of the moving object, t is the time threshold of the database The time point in , o(t) is the position of the moving object o when the time is t, Par(Cr) is a set of participants of a group Cr; Preset Definition 2: Given a moving object A collection of trajectories, supported by thresholds , variable threshold , and the lifetime threshold , a group Cr is the order of snapshot clusters within consecutive time stamps, ie , which meets the following requirements: Cr, the lifetime of Cr represented by _T is not less than ,Right now ; exist at any time at least object, that is ;The distance between any two consecutive pairs of snapshot clusters is not greater than , ; Since a snapshot set snapshotcluster is essentially a collection of points, given two point sets P and Q, the hausodrff distance between point sets P and Q defined as: ; time threshold in the database At each time point of , the trajectories of moving objects are concentrated based on the density to find all the snapshot clusters. First, the original trajectories are simplified by the curve data compression algorithm, and then concentrated in the straight part. Each cluster of the straight part contains objects It is possible to form a snapshot cluster at some point in time, and output the database of the snapshot cluster ; (2) The discovery phase of the group, that is, from Find all closed groups in : (2.1) Definition Lemma 1: In the group in, if not present , such that if the group Cr is attached to will produce a new group, then the group Cr is a closed group, otherwise, the group Cr is not closed, among them, the cluster is the snapshot cluster when the time is t _i in the group Cr, the cluster is the snapshot cluster when the time is t _j in the group Cr; (2.2) Use rangesearch, R-tree index cluster method or grid index cluster method to discover closed groups by attaching snapshot clusters to the current set of group participants V at the next point in time, group participants It is a collection of clusters that may grow into a group, which is equivalent to a candidate group; The method of arranging index clusters RangeSearch: RangeSearch() is to find the distance from the cluster set at the current timestamp The Hausdorff distance is no greater than clusters, the implementation is to calculate each of , i.e. to calculate for each pair between the current crowd participant and the cluster at the current time point , find out from no greater than all clusters of (3) Gathering and investigation stage: Use the test partition algorithm TAD or the bit vector signature test partition algorithm to confirm whether each closed group obtained in the previous step is a closed aggregate or whether it contains a closed aggregate. 2. A method for quickly discovering aggregation patterns from moving track data according to claim 1, wherein the method of using the permutation index cluster is to attach the snapshot cluster to the current group participant at the next point in time The specific steps to find a closed group in the set of V include: Get the database of the snapshot cluster , preset the support threshold of a group , Preset the threshold of the lifetime of a group and the thresholds for the variables preset in the definition of the group ; at each timestamp , check the last cluster of each group Cr, and judge whether the group Cr can be expanded by adding another cluster: to obtain the current timestamp, use the formula Calculate the set of clusters Each cluster in to cluster The Hausdorff distance, and find the distance from The Hausdorff distance is not greater than of clusters , where C is the set of clusters, is the set of clusters at the current timestamp, and is contained in ; if a cluster is found Then it can be extended, the extended group Insert as new participant after cluster participant V; if cluster not found That is, it cannot be extended, and when the lifetime of Cr is not less than , then according to Lemma 1, the group Cr is a closed group; if no cluster , and the lifetime of Cr is less than , then Cr is not a group; at any time stamp, a cluster R that cannot be attached to any existing group participant is treated as a new group participant. 3. A method for quickly finding aggregation patterns from moving track data according to claim 1, wherein the method of utilizing the R-tree index cluster is to attach the snapshot cluster to the current group participation at the next point in time. The specific steps to find a closed group in the set of V include: Get the database of the snapshot cluster , preset the support threshold of a group , preset the threshold of the lifetime of a group and the thresholds of the variables preset in the definition of the group ; use Represents a cluster The minimum rectangular boundary MBR, with the formula Represents the minimum distance between two rectangles, predefined Lemma 2: Given two clusters and , , c is a cluster in C; Get the last cluster for each cluster Cr , For any cluster in the group Cr, use the formula Calculate the set of clusters Each cluster in to cluster Hausdorff distance; use formula look up When , retrieve the set of clusters And take out a set of participants, the set of participants is the same as The minimum distance is not greater than , and then refine these participants to find all , where the R tree is used to index the minimum rectangular boundary of the clusters in the set C of clusters, and a query window is established based on the R tree, and the window is a parameter of of To expand the MBR, the clusters contained in the node and not overlapping with the window are not participants; Predefined Lemma 3: Let Represents the ath side of the rectangle M, a=(1, 2, 3, 4), defines the distance function for: , then there is , that is, the calculated distance from Cr is less than A collection of snapshot clusters; use formula Retrieve the participants in the R-tree, and then refine these participants to obtain the set of clusters satisfying Lemma 3, where the R-tree is used to index the MBRs of the clusters in C, and a query window is built based on the R-tree, which is The parameter is of Expand the MBR, by expand Each side of the so that it contains four rectangles, the rectangles are Indicates that a=(1, 2, 3, 4), in the traversal of the R tree, only when a node intersects with all four rectangles will the node be further checked; Check the last cluster of each group participant to see if it can be extended by appending another cluster, if so, the expanded group participant is inserted as a new participant after the set V of group participants; if not, it cannot be extended , and the lifetime of Cr is not less than , then according to Lemma 1, the group Cr is a closed group; if it cannot be extended, and the lifetime of Cr is less than , then Cr is not a group; at any time stamp, a cluster R that cannot be attached to any existing group participant is treated as a new group participant. 4. A method for quickly discovering aggregation patterns from moving trajectory data according to claim 1, characterized in that, using the grid index cluster method, the snapshot cluster is attached to the current group participation at the next time point The specific steps to find a closed group in the set of V include: Get the database of the snapshot cluster , preset the support threshold of a group , preset the threshold of the lifetime of a group and the thresholds of the variables preset in the definition of the group ; Define the area of influence: For a cell located in row a and column b in a grid G , its area of influence is the same as The minimum distance is not greater than A collection of units, that is ; First, use grid G to divide the entire space of group Cr into multiple units g, and each unit has a side length equal to The square of , for each timestamp t, walk through the set of clusters After that, build a grid index with two data structures , the grid index contains a list of cells for each cluster in , where the list of cells Records the cells occupied by the cluster and each unit The reverse list of , which stores the clusters covered on this unit; The area of influence of a cell consists of points in g at a distance no greater than points of , giving the last cluster of the group Cr as the query cluster and cluster The grid index of the next timestamp corresponding to the time ; Pruning phase: from Select each unit g in and find where its cell list is the same as Intersecting clusters where only the covering Only the cluster of the influence area of each unit in the cluster can be the reference, otherwise there will be at least one disconnected cluster in the cluster distance ratio far point; Refinement stage: Since the distance between any two points in the same unit must not be greater than , and in the limit, if ,same , so only the cells in different collections need to be examined , to find the distance in the set of clusters The Hausdorff distance is no greater than The clusters, that is, to retrieve each cluster in the group Cr, for any cluster in the group Cr , first add a set of units to and to get their common unit, for Point p in , calculate point p and The minimum Hausdorff distance of , and only need to calculate to point p and Hausdorff distance to points falling within the area of influence, express and The minimum Hausdorff distance between; If found from The Hausdorff distance is not greater than of clusters Then it can be extended, the extended group Insert as new participant after cluster participant V; if cluster not found That is, it cannot be extended, and when the lifetime of Cr is not less than , then according to Lemma 1, the group Cr is a closed group. 5. a kind of method according to claim 1 finds aggregation mode fast from moving track data, it is characterized in that, in described utilization test division algorithm, confirm whether each closed group that last step obtains is closed aggregation or Is it included in the closed aggregate: Preset definition 3: Given a group Cr object o is called a participant if and only if it appears in Cr at least In a snapshot cluster, let represents the collection of snapshot clusters in Cr containing object o, i.e. , then the participant of Cr is the collection of objects ; Using the test division algorithm, start the test from the whole closed group, calculate whether it participates in activities for each snapshot cluster in the group Cr according to Definition 3 to judge whether it is a participant, and then check the participants in each cluster in the group number, each closed cluster is then tested according to the predefined clustering method to see if it is an aggregate; if not, invalid clusters are identified, which do not have enough participants, and the cluster is divided into several sub-columns by removing these clusters , where, for each subcolumn that is still a group, the test of whether the closed group is an aggregation is repeated again using the predefined aggregation method, until no further groups are found. 6. A kind of method for quickly finding aggregation pattern from moving track data according to claim 1, is characterized in that, described utilizes bit vector signature test division algorithm, confirms whether each closed group that last step obtains is closed The specific steps for aggregation or whether to include closed aggregation include: a) is the trajectory of each moving object of the group Cr Construct a bit vector signature BVS, and each BVS is a bit vector of length n, each bit of the vector represents the existence of o in the matching cluster, wherein, the BVS of all objects in the group Cr can be passed through the group Single-scan construction, and BVS only needs to be constructed once to be used in all recursive processes of TAD; b) Test steps: use The BVS representing an object o, to test whether the group Cr is a closed group, is to calculate The number of digits in 1, that is, the Hamming weight of a bit vector, uses traversal The Hamming weight of the bit vector is obtained by means of all bits of the method or the counting method based on the binary tree mode. When using the counting method based on the binary tree mode, first get per The number of 1s in the bit, and then get every 4, that is The number of 1 in the bit, until the mth time, when 2 ^m = n, get the number of 1 in every n bit, any bit vector of n bits, its Hamming weight can be used The following steps are obtained, set the mask m, the mask m is a bit vector with the same length as the BVS; when the value of the Hamming weight is greater than or equal to , the closed group is a closed aggregate or contains a closed aggregate; c) Division step: If a group is not aggregated, it is divided into a series of sub-columns, that is, the bit vector of the trajectory of each moving object is divided into a series of sub-vectors, extracted from the original BVS with a mask, and the mask and sub-group The same bit is 1, and the other bits are 0; by performing an "AND" operation on the original BVS and the mask, a new BVS is obtained, in which the bit of the desired subgroup remains 1 and the other bits are 0, so, Return a series of masks, and pass the mask into the test step of the subgroup, that is, the test step directly uses the mask to get the BVS of the object that matches the subgroup. 7. A method of quickly discovering aggregation patterns from moving track data according to claim 1, wherein the track of moving objects should be periodically added to the database , the time domain is The database of trajectories of moving objects is , in the collected time domain as new trajectory and add to Later in the middle, the extended time domain is obtained , which corresponds to the updated database . 8. according to claim 6 or 7 described a kind of method of quickly finding aggregation mode from moving trace data, it is characterized in that, after updating database, the specific steps of finding the closed aggregation of new growth comprises: 1) Extension: Predefined Lemma 4: Lemma 4: Given a closed group in , if its last cluster is not in the most recent time point of ,in is the time for is a collection of clusters, then Cr is in is not scalable in , and Lemma 4 shows that only a part of groups or group participants in previous databases are scalable; judge The middle cluster sequence is in whether the set CS at the end can be expanded into new clusters whose sequence of clusters contains closed clusters in the previous database and cluster participants of length less than k; After finding a closed group in step (2), save the group participants and closed group at the end of the last timestamp, and then after receiving a new set of trajectories and convert it to a clustered database After that, move the time cursor Set as , and change the current group participant from V to CS; 2) Aggregate update: Assume in a group has been expanded to A new closed group in , then find out When closed aggregation in , directly to Use TAD algorithm or bit vector TAD algorithm; Predefined Lemma 5: Use IC(Cr) to represent the set of invalid clusters in group Cr, then we have ,because The addition of new clusters in Some non-participants in may become participants, namely Aggregations in may expand either with Neighboring aggregation fusion in ; if found belongs to invalid cluster of , then all closures before tj gather at remains unchanged, that is, Theorem 2: When an invalid cluster is given ,in , then any closed aggregate exist remain closed in Test steps: When using the bit vector TAD algorithm, first for Constructs a BVS for each moving object and detects invalid clusters; After getting a series of invalid cluster ICs during the test phase, find out when the time stamp previous invalid clusters, i.e. , , and there is no make cluster , ,only The subgroups in need to be further examined because they contain new or updated aggregates.