fulfills the role of the select cla

fulfills the role of the select clause (σ) of the support query. We assume that the tid lists of the itemsets (the lists of tuples of J where the itemsets occur) are accessible to us. Finally, these tid lists are translated to their appropriate KeyID lists. Translating a tid list T to a KeyID list comes
down to performing the projection πK (J ✶ T ) to each key
K . This can be done efficiently by using lookup tables that
can be created during the construction of J . At the end, the relative minimum support threshold is imposed for each itemset’s KeyID list, and the frequent itemsets are reported. The advantage of the Naive algorithm is that it can be implemented as a wrapper around an existing itemset min- ing algorithm. However, the computation of the full outer join can be expensive in both time and memory, making it infeasible to use on larger databases. Moreover, too many candidates are generated. We can only prune itemsets that

Algorithm 2 Keyclat: computation of itemsets’ KeyID lists
Input: Set of k-itemsets LP having a common prefix P ;
relative support threshold minsup
Output: Set F of frequent itemsets I with prefix P
1: for I 0 in LP do
2: for I 00 in LP with I 00 > I 0 do
3: I := I 0 ∪ I 00
4: E1 , E2 := entity of suffix items I 0 P, I 00 P resp.
5: for i ∈ {1, 2} do
6: Ki := key(Ei )
7: KeyIDs(IKi ) := KeyIDs(I 0 00
Ki ) ∩ KeyIDs(IKi )
8: pKeyIDsi (I ) := Propagate(KeyIDs(IKi ))
9: for E ∈ E {E1 , E2 } do
10: K := key(E)
11: KeyIDs(IK ) := pKeyIDs1 (IK ) ∩ pKeyIDs2 (IK )
∩ KeyIDs(I 0 ) ∩ KeyIDs(I 00 )

are infrequent with respect to abssup, but many candidate

12: supp(IK

K K
KeyIDs(IK )|

sets that are frequent in J may turn out to be infrequent for
all keys K with respect to the minsup threshold.
The SMuRFIG algorithm (see Algorithm 1) does not suffer from these disadvantages, i.e. it is efficient in both time and memory. It uses the concept of KeyID list propagation. First, the KeyID lists of all items are fetched from the data in their respective entities (Line 3), and then these KeyID lists are propagated to all other entities (Line 5). The propagation

13: if supp(IK ) ≥ minsup × |E| then
14: FI 0 := FI 0 ∪ IK
15: F := F ∪ FI 0 ∪ Keyclat(FI 0 , minsup)
16: return F


The time complexity of SMuRFIG is as follows. Per itemset at most three intersections are required for each

function recursively translates a KeyID list from one entity

entity E, taking O(P

E|), where |E| is the number

Ei to its adjacent entities Ej , until all entities are reached.


of tuples in E. The

E∈E |
propagation function is executed at

Translating a KeyID list Ti from Ei to Ej via Ri,j is equiv- alent to executing the relational query πkey(Ej ) (Ti ✶ Ri,j ).
It is easy to verify that we now have the KeyID lists of all

most twice and uses each relation R once, amounting to
O(P |R|). Hence, the time complexity of SMuRFIG is
O (|F | • size(DB)), where |F | is the total number of frequent

items for all keys K , and hence their supports.
Next, the (frequent) singleton itemsets are combined into

itemsets and size(DB) = P |E| +

R∈R |R| is the size

larger sets by the Keyclat function (Algorithm 2), which is the core of SMuRFIG. The search space is traversed depth- first. In each recursion, two k-itemsets I 0 and I 00 with a common prefix P (initially empty) are combined to form a
new candidate set I = I 0 ∪ I 00 of size k + 1. To compute the

of the database. SMuRFIG only requires a small amount of
patterns to be stored in memory simultaneously. When an itemset of length k is generated, we have (k2 + k)/2 previous itemsets in memory due to the depth-first traversal. For each of these itemsets, KeyID lists are stored for all keys. The
maximal total size of these lists for one itemset is P E .

support of I , we first determine that the entity tables of the


Next to this, we also keep all relations R in memo

E∈E | |
c

suffixes of I 0 and I 00 are E1 and E2 (Line 4). We intersect the
KeyID lists of I 0 and I 00 in E1 and E2 , to obtain the support of I in E1 and E2 (Line 7), and then these KeyID lists are

ry, whi h
are needed in the propagation function. To sum up, if l is the size of the largest frequent itemset, then SMuRFIG’s worst
case memory consumption is O `l2 • P P ´

propagated to all other entities (Line 8). For these remaining
entities E with key K , it does not necessarily hold that
KeyIDs(I 0 ) ∩ KeyIDs(I 00 ) results in KeyIDs(IK ). We must

E∈E |E| +

R∈R |R| .

Kết quả (Việt) 1:

thực hiện tốt vai trò của các mệnh đề chọn (σ) của các truy vấn hỗ trợ. Chúng tôi giả định rằng tid danh sách itemsets (danh sách tuples J nơi xảy ra các itemsets) có thể truy cập cho chúng tôi. Cuối cùng, các danh sách tid được dịch để danh sách KeyID thích hợp của họ. Dịch một danh sách tid T vào một danh sách KeyID đến
xuống để thực hiện phép chiếu πK (J ✶ T) cho mỗi phím
K. Điều này có thể được thực hiện một cách hiệu quả bằng sử dụng tra cứu các bảng mà
có thể được tạo ra trong việc xây dựng J. Ở cuối, ngưỡng hỗ trợ tương đối tối thiểu áp dụng cho mỗi itemset KeyID danh sách, và itemsets thường xuyên được báo cáo. Lợi thế của các thuật toán ngây thơ là rằng nó có thể được thực hiện như là một wrapper quanh một thuật toán min-ing itemset sẵn có. Tuy nhiên, tính toán tham gia đầy đủ bên ngoài có thể tốn kém trong cả thời gian và bộ nhớ, làm cho nó infeasible để sử dụng trên cơ sở dữ liệu lớn hơn. Hơn nữa, quá nhiều ứng cử viên được tạo ra. Chúng tôi có thể chỉ prune itemsets mà

thuật toán 2 Keyclat: tính toán itemsets' KeyID danh sách
đầu vào: thiết lập của k-itemsets LP có chung một tiền tố P;
tương đối hỗ trợ ngưỡng minsup
đầu ra: Thiết lập F itemsets thường xuyên tôi với tiền tố P
1: cho tôi 0 trong LP làm
2: cho tôi giờ LP với tôi 00 > tôi 0 làm
3: tôi: = tôi 0 u tôi 00
4: E1, E2: = thực thể các hậu tố tôi 0 P, tôi 00 P này
5: cho tôi ∈ {1, 2} làm
6: Ki: = phím (Ei)
7: KeyIDs (IKi): = KeyIDs (tôi 0 00
Ki) ∩ KeyIDs (IKi)
8: pKeyIDsi (I): = Propagate (KeyIDs (IKi))
9: cho E ∈ E {E1, E2} làm
10: K: = phím (E)
11: KeyIDs (IK):= pKeyIDs1 (IK) ∩ pKeyIDs2 (IK)
∩ KeyIDs (I 0) ∩ KeyIDs (I 00)

là không thường xuyên đối với abssup, nhưng nhiều ứng cử viên

12: supp (IK

K K
KeyIDs (IK) |

bộ có thường xuyên trong J có thể bật ra được không thường xuyên cho
tất cả phím K đối với minsup ngưỡng.
The SMuRFIG thuật toán (xem thuật toán 1) không ảnh hưởng từ những bất lợi, tức là đó là hiệu quả trong thời gian và bộ nhớ. Nó sử dụng các khái niệm về KeyID danh sách tuyên truyền. Trước tiên, các danh sách KeyID của tất cả các mục được lấy từ các dữ liệu trong các tổ chức tương ứng của họ (dòng 3), và sau đó các danh sách KeyID được truyền đến tất cả các thực thể khác (dòng 5). Tuyên truyền

13: nếu supp (IK) ≥ minsup × |E| sau đó
14: FI 0: = FI 0 u IK
15: F: = F u FI 0 u Keyclat (FI 0, minsup)
16: trở về F


phức tạp thời gian của SMuRFIG là như sau. Mỗi itemset tối đa ba nút giao thông được yêu cầu cho mỗi

đệ quy chức năng dịch một danh sách KeyID từ một thực thể

thực thể E, dùng O (P

E|), nơi |E| laø soá

Ei cho các cơ quan lân cận Ej, cho đến khi đạt được tất cả các thực thể.


của tuples trong E. Các

E∈E |
tuyên truyền chức năng được thi hành tại

Dịch một danh sách KeyID Ti từ Ei để Ej via Ri, j là equiv-alent để thực hiện truy vấn quan hệ πkey (Ej) (Ti ✶ Ri, j).
nó rất dễ dàng để xác minh rằng chúng tôi bây giờ có các danh sách KeyID của tất cả

đặt hai lần và sử dụng mỗi quan hệ R một lần, chiếm
O(P |R|). Do đó, sự phức tạp thời gian của SMuRFIG là
O (|F | • size(DB)), nơi |F | là tổng số thường xuyên

mục cho tất cả các phím K, và do đó của họ hỗ trợ.
tiếp theo, itemsets (thường xuyên) singleton được kết hợp thành

itemsets và size(DB) = P |E|

R∈R |R| là kích thước

bộ lớn hơn của các chức năng Keyclat (thuật toán 2), là cốt lõi của SMuRFIG. Không gian tìm kiếm ngang sâu đầu tiên. Trong mỗi đệ quy, hai k-itemsets tôi 0 và tôi 00 với một phổ biến tiền tố P (ban đầu trống) được hợp nhất để lập một
ứng cử viên mới thiết lập tôi = tôi 0 u tôi 00 của kích thước k 1. Để tính toán các

của cơ sở dữ liệu. SMuRFIG chỉ đòi hỏi một số tiền nhỏ của
mẫu sẽ được lưu trong bộ nhớ cùng một lúc. Khi một itemset chiều dài k được tạo ra, chúng tôi có (k2 k) / 2 trước itemsets trong bộ nhớ do traversal sâu đầu tiên. Đối với mỗi của những itemsets, danh sách KeyID được lưu trữ cho tất cả các phím. Các
tối đa tổng kích thước của các danh sách cho một itemset là P E.

hỗ trợ của tôi, chúng tôi đầu tiên xác định rằng các bảng tổ chức các


bên cạnh này, chúng tôi cũng giữ tất cả quan hệ R trong bản ghi nhớ

E∈E | |
c

hậu tố của tôi 0 và tôi 00 là E1 và E2 (dòng 4). Chúng tôi giao nhau các
KeyID danh sách của tôi 0 và tôi 00 trong E1 và E2, để có được sự hỗ trợ của tôi trong E1, E2 (tuyến 7), và sau đó các danh sách KeyID

ry, whi h
là cần thiết trong các chức năng tuyên truyền. Tổng kết, nếu l là kích thước lớn nhất itemset thường xuyên, sau đó SMuRFIG's tồi tệ nhất
tiêu thụ bộ nhớ trường hợp là O ' l2 • P P ´

truyền đến tất cả các thực thể khác (Line 8). Đối với những còn lại
thực thể E với phím K, nó không nhất thiết phải giữ mà
KeyIDs (I 0) ∩ KeyIDs (I 00) kết quả trong KeyIDs (IK). Chúng ta phải

E∈E |E|

R∈R |R| .

Kết quả (Việt) 2:

thực hiện tốt vai trò của mệnh đề select (σ) của các truy vấn hỗ trợ. Chúng tôi giả định rằng danh sách tid của các tập phổ biến (danh sách các bộ dữ liệu của J nơi tập phổ biến xảy ra) có thể truy cập cho chúng tôi. Cuối cùng, các danh sách tid được chuyển vào danh sách KeyID thích hợp của họ. Dịch một danh sách tid T vào một danh sách KeyID đến
xuống để thực hiện πK chiếu (J ✶ T) cho mỗi phím
K. Điều này có thể được thực hiện một cách hiệu quả bằng cách sử dụng các bảng tra cứu mà
có thể được tạo ra trong quá trình xây dựng J. Cuối cùng, ngưỡng hỗ trợ tối thiểu tương đối là đối với danh sách KeyID mỗi tập phổ biến, và các tập phổ biến được báo cáo. Ưu điểm của thuật toán Naive là nó có thể được thực hiện như một bọc xung quanh một min-ing tập phổ biến thuật toán hiện có. Tuy nhiên, việc tính toán đầy đủ bên ngoài tham gia có thể tốn kém cả thời gian và bộ nhớ, làm cho nó không khả thi để sử dụng trên cơ sở dữ liệu lớn hơn. Hơn nữa, quá nhiều ứng cử viên được tạo ra. Chúng tôi chỉ có thể tỉa tập phổ biến rằng thuật toán 2 Keyclat: tính toán của 'KeyID tập phổ biến danh sách đầu vào: Bộ k-tập phổ biến LP có một tiền tố P chung; hỗ trợ tương đối ngưỡng minsup Output: Set F của tập phổ biến tôi với tiền tố P 1: cho tôi 0 trong LP làm 2: cho tôi 00 trong LP với tôi 00> 0 Tôi làm 3: I: = I 0 ∪ tôi 00 4: E1, E2:. = thực thể của các mặt hàng hậu tố tôi 0 P, tôi 00 P resp 5 : cho i ∈ {1, 2} làm 6: Ki: = phím (Ei) 7: KeyIDs (IKI): = KeyIDs (tôi 0 00 Ki) ∩ KeyIDs (IKI) 8: pKeyIDsi (I): = Tuyên truyền (KeyIDs (IKI)) 9: cho E ∈ E {E1, E2} làm 10: K: = phím (E) 11: KeyIDs (IK): = pKeyIDs1 (IK) ∩ pKeyIDs2 (IK) ∩ KeyIDs (tôi 0) ∩ KeyIDs (tôi 00) hiếm khi xảy ra đối với abssup với, nhưng nhiều ứng cử viên 12: supp (IK KK KeyIDs (IK) | bộ mà thường xuyên trong J có thể bật ra được thường xuyên cho . tất cả các phím K đối với ngưỡng minsup với Các thuật toán SMuRFIG (xem Thuật toán 1) không bị ảnh hưởng từ những khó khăn, tức là nó có hiệu quả trong cả thời gian và bộ nhớ. Nó sử dụng các khái niệm về KeyID danh sách tuyên truyền. Đầu tiên, danh sách KeyID của tất cả các mục được lấy từ các dữ liệu trong các tổ chức tương ứng của họ (dòng 3), và sau đó những danh sách KeyID được truyền cho tất cả các đơn vị khác (dòng 5). Công tác tuyên truyền 13: nếu supp (IK) ≥ minsup × | E | sau đó 14: FI 0: = FI 0 ∪ IK 15: F: = F ∪ FI 0 ∪ Keyclat (FI 0, minsup) 16: trở lại F Thời gian phức tạp của SMuRFIG là như sau. Mỗi tập phổ biến tối đa là ba nút giao thông được yêu cầu cho mỗi chức năng đệ quy dịch một danh sách KeyID từ một thực thể thực thể E, lấy O (P E |), trong đó | E | là số Ei cho các đơn vị lân cận Ej, cho đến khi tất cả các thực thể được đạt tới. các bộ dữ liệu trong E. E ∈ E | chức năng tuyên truyền được thực hiện tại dịch một danh sách KeyID Ti từ Ei để Ej qua Ri, j là equiv-alent để thực hiện truy vấn πkey quan hệ (Ej) (Ti ✶ Ri, j). Nó rất dễ dàng để xác minh rằng bây giờ chúng tôi có danh sách của tất cả các KeyID hai lần nhất và sử dụng mỗi quan hệ R một lần, lên tới O (P | R |). Do đó, độ phức tạp của SMuRFIG là O (| F | • Kích thước (DB)), trong đó | F | là tổng số thường xuyên . mục cho tất cả các phím K, và do đó hỗ trợ của họ Tiếp theo, (thường xuyên) tập phổ biến là singleton kết hợp thành tập phổ biến và kích thước (DB) = P | E | + R ∈ R | R | là kích thước bộ lớn hơn bởi các chức năng Keyclat (Thuật toán 2), đó là cốt lõi của SMuRFIG. Không gian tìm kiếm là đi qua sâu đầu tiên. Trong mỗi đệ quy, hai k-tập phổ biến tôi 0 và tôi 00 với một tiền tố P chung (ban đầu có sản phẩm nào) được kết hợp để tạo thành một bộ ứng cử viên mới I = I 0 ∪ tôi 00 kích thước k + 1. Để tính toán của cơ sở dữ liệu. SMuRFIG chỉ cần một lượng nhỏ của mô hình được lưu trữ trong bộ nhớ cùng một lúc. Khi một tập phổ biến có độ dài k được tạo ra, chúng tôi có (k2 + k) / 2 tập phổ biến trước đó trong bộ nhớ do traversal sâu đầu tiên. Đối với mỗi tập phổ biến, danh sách KeyID được lưu trữ cho tất cả các phím. Các . tổng kích thước tối đa của các danh sách này cho một tập phổ biến là PE hỗ trợ của tôi, đầu tiên chúng tôi xác định rằng các bảng thực thể của Tiếp đó, chúng tôi cũng giữ tất cả các mối quan hệ R trong bản ghi nhớ E ∈ E | | c hậu tố của tôi 0 và tôi 00 là E1 và E2 (Dòng 4). Chúng tôi giao với danh sách KeyID của tôi 0 và tôi 00 trong E1 và E2, để có được sự hỗ trợ của tôi trong E1 và E2 (dòng 7), và sau đó những danh sách KeyID là ry, whi h là cần thiết trong chức năng tuyên truyền. Tóm lại, nếu tôi là kích thước của các tập phổ biến lớn nhất, sau đó tồi tệ nhất của SMuRFIG trường hợp tiêu thụ bộ nhớ là O `l2 • PP ' tuyên truyền cho tất cả các đơn vị khác (Line 8). Còn lại cho các đơn vị điện tử với phím K, nó không nhất thiết cho rằng KeyIDs (tôi 0) ∩ KeyIDs (tôi 00) kết quả trong KeyIDs (IK). Chúng ta phải E ∈ E | E | + R ∈ R | R |.