Thuật toán CBA bao gồm hai giai ñoạn là: giai ñoạn sinh ra luật (gọi là CBA- RG), dựa trên thuật toán Apriori ñể tìm các luật liên kết. giai ñoạn thứ hai là giai ñoạn xây dựng bộ phân lớp dựa trên các luật của giai ñoạn 1(gọi là CBA-CB).
5.2.1. Thuật toán CBA-RG
Công việc quan trọng của CBA-RG là tìm ra tất cả các luật có hỗ trợ minsup ở
trên. Một luật có dạng như sau:
<condset, y>
Trong ñó condset là tập các ñiều kiện và y Y là một nhãn lớp. Số hỗ trợ của condset (gọi là condsupCount) là số mẫu trong D mà bao gồm condset. Số hỗ trợ của các luật (gọi là rulesupCount) là số mẫu trong D bao gồm condset và ñược gắn nhẵn lớp y. Mỗi luật ñược biểu diễn như sau:
Condset -> y,
Toàn bộ hỗ trợ là (rulesupCount/|D|)*100%, trong ñó |D| là kích thước tập dữ
liệu và toàn bộñộ chắc chắn là (rulesupCount/condsupCount)*100%.
Các luật thỏa mãn minsup ñược gọi là luật thường xuyên, trong khi luật còn lại gọi là luật không thường xuyên.
Ví dụ:
<{(A,1), (B,1)}, (Class,1)> ,
Trong ñó A và B là các thuộc tính. Nếu số hỗ trợ của condset {(A,1), (B,1)} là 3, số hỗ trợ của luật là 2 và tổng số mẫu trong D là 10, thì hỗ trợ của luật là 20%, và ñộ
chắc chắn là 66.7%. Nếu minsup là 10% thì luật thoả mãn tiêu chuẩn minsup. Ta nói nó là thường xuyên.
Tất cả các luật có cùng condset, thì những luật có ñộ chắc chắn cao nhất sẽ ñược chọn là luật hợp lý (Possible Rule-PR) biểu diễn tập các luật này. Nếu có nhiều hơn một luật có cùng giá trịñộ chắc chắn cao nhất thì sẽ chọn một luật ngẫu nhiên. Ví dụ, ta có hai luật có cùng giá trị condset:
1. <{(A, 1), (B, 1) }, (class:1)> 2. <{(A, 1), (B, 1) }, (class:2)>
Giả sử số hỗ trợ của condset là 3. Số hỗ trợ của luật thứ nhất là 2, và của luật thứ 2 là 1 thì ñộ chắc chắn của luật 1 là 66.7%, trong khi ñó của luật 2 là 33.3%. Với 2 luật ta chỉ có 01 PR (giả sử |D|=10): (A, 1) , (B, 1) -> (class, 1) [supt = 20%, confd = 66.7%].
Nếu ñộ chắc chắn lớn hơn minconf thì ta nói luật là chính xác. Tập các luật kết hợp (CARs) bao gồm tất cả các PR mà cả thường xuyên và chính xác.
Thuật toán CBA-PG
Thuật toán CBA-PG sinh ra tất cả phần tử luật hay xuất hiện bằng cách kiểm tra nhiều lần trên dữ liệu. Trong lần kiểm tra ñầu, nó ñếm hỗ trợ của phần tử luật riêng biệt và xác ñịnh xem nó có hay xảy ra. Trong mỗi lần kiểm tra bên trong, nó bắt ñầu tìm kiếm các phần tử luật hay xuất hiện trong lần thử trước. Nó dùng các phần tử luật này ñể sinh các phần tử luật mới có thể có (gọi là các phần tử luật ứng cử). Sự hỗ trợ
thực tế của các phần tử luật ứng cử này tính trong quá trình kiểm tra dữ liệu. Cuối mỗi lần kiểm tra, nó xác ñịnh phần tử luật nào hay xuất hiện. Từ tập phần tử luật hay xuất hiện này sẽ sinh ra các luật (CAR).
Gọi phần tử luật thứ k là một phần tử luật khi condset có k thành phần. Gọi Fk là tần số của tập phần tử luật k. Mỗi thành phần của tập này có dạng:
<(condset, condsupCount), (y, rulesupCount)>
Gọi Ck là tập ứng cử các phần tử luật thứ k. Thuật toán CBA-RG như sau: 1 F1 = {large 1-ruleitems};
2 CAR1 = genRules(F1);
3 prCAR1 = pruneRules(CAR1); 4 for (k = 2; Fk-1≠ Ø; k ++) do
5 Ck = candidateGen(Fk-1); 6 for each data case d ∈ D do
7 Cd = ruleSubset(Ck,d);
8 for each candidate c ∈ Cd do
9 c.condsupCount++;
11 end 12 End 13 Fk = {c ∈ Ck | c.rulesupCount ≥ minsup}; 14 CARr = genRules(Fk); 15 prCARk = pruneRules(CARk); 16 End 17 CARs =
U
kCAR ; k 18 prCARk =U
k prCAR ; kDòng 1-3 là lần kiểm tra ñầu tiên của thuật toán. Nó ñếm số các phần tử và lớp xảy ra ñể xác ñịnh các phần tử luật thứ 1. Từ tập phần tử luật thứ nhất, tập CAR sinh ra bởi tạo luật (dòng 2). CAR1 sẽ ñược cắt tỉa (dòng 3). Quá trình cắt tỉa cũng ñược thực hiện trong mỗi lần kiểm tra bên trong cho CARk (dòng 15). Hàm pruneRules ñể tính tỉ
lệ lỗi dựa trên phương pháp cắt tỉa của C4.5 (Quinlan 1992). Nó cắt luật như sau: nếu luật r có tỉ lệ lỗi cao hơn luật r’. (r’ có ñược bằng cách xóa bớt một ñiều kiện từ ñiều kiện của r), khi ñó luật r bị cắt bỏ. Quá trình cắt tỉa làm giảm số luật tạo ra có thật.
Với mỗi lần kiểm tra bên trong, gọi là kiểm tra k, thuật toán thực hiện 4 phép toán cơ bản. Thứ nhất, các phần tử luật hay xuất hiện Fk-1 tìm trong lần kiểm tra thứ (k- 1) ñể tạo ra các phần tử luật ứng cử Ck sử dụng hàm candidateGen (dòng 5). Sau ñó, nó duyệt hết CSDL và cập nhật số lượng hỗ trợ của các ứng cử viên Ck (dòng 6-12). Sau ñó, các phần tử luật mới ñược xác ñịnh kí hiệu là Fk (dòng 13), tiếp theo thuật toán sinh ra các luật CARk sử dụng hàm genRules (dòng 14). Cuối cùng, thực hiện cắt tỉa luật (dòng 15).
Hàm candidateGen tương tự như hàm Aprior-gen trong thuật toán Aprior. Hàm ruleSubset lấy tập các phần tử luật ứng cử Ck và mẫu dữ liệu d ñể tìm toàn bộ phần tử
luật trong Ck mà tập condset ñược hỗ trợ bởi d. Phép toán trong dòng 8 và 10 cũng giống như thuật toán Aprior. Sự khác biệt ở chỗ chúng ta cần gia tăng số lần hỗ trợ cho tập condset và phần tử luật là riêng biệt trong khi ñó thuật toán Aprior chỉ cập nhật một lần. ðiều này cho phép chúng ta tính toán ñộ tin cậy của phần tử luật. Chúng cũng rất có ích trong quá trình cắt tỉa cây.
Tập cuối cùng của luật phân lớp là CARs (dòng 17). Các luật còn lại sau khi cắt tỉa là prCARs (dòng 18).
5.2.2. Xây dựng bộ phân lớp
Phần này trình bày thuật toán CBA-CB ñể xây dựng bộ phân lớp sử dụng CARs (hay prCARs). ðể tạo bộ phân lớp tốt nhất, toàn bộ luật sẽ ñưa vào quá trình ñánh giá toàn bộ tập con có thể có trong quá trình huấn luyện dữ liệu và chọn tập con có dãy luật ñúng cho lỗi nhỏ nhất. Có 2m tập con, trong ñó m là số luật, có thể hơn 10000 luật,
không xét ñến dãy luật khác nhau. Trước khi trình bày thuật toán, chúng ta ñịnh nghĩa tổng thứ tự trên các luật sinh ra.
ðịnh nghĩa: cho 2 luật ri và rj và ri rj (gọi ri trước rj hoặc ri có thứ tự lớn hơn rj) nếu
1. ñộ tin cậy của ri lớn hơn rj hoặc
2. ñộ tin cậy của chúng như nhau, nhưng hỗ trợ của ri lớn hơn rj, hoặc 3. cảñộ tin cậy và hỗ trợ của ri và rj như nhau, nhưng ri sinh ra trước rj;
Gọi R là tập các luật sinh ra (ví dụ CARs hoặc pCARs), và D là dữ liệu huấn luyện. Ý tưởng chính của thuật toán là chọn tập luật ưu tiên cao trong R bao trùm D.
Bộ phân lớp có dạng như sau: <r1, r2, …, rn, default_class>,
Trong ñó, ri R, ra rb nếu b > a, default_class là lớp mặc ñịnh. ðể phân lớp mẫu chưa biết, luật ñầu tiên thỏa mãn mẫu sẽ ñược chọn ñể phân lớp. Nếu không có luật nào áp dụng cho mẫu thì lấy lớp mặc ñịnh như C4.5.
Thuật toán bao gồm 3 giai ñoạn:
Giai ñoạn 1. với mỗi mẫu d, ta tìm cả luật ưu tiên cao nhất (gọi là cRule) có phân lớp ñúng d, và luật ưu tiên cao nhất (gọi là wRule) có phân lớp sai d. Nếu cRule wRule thì mẫu ñược bao trùm bởi cRule. ðiều này thỏa mãn ñiều kiện 1 và 2 dưới
ñây. Ta dùng cRule ñể chỉ rằng phân lớp mẫu ñúng. Nếu wRule cRule, thì phức tạp hơn bởi vì ta không thể quyết ñịnh luật nào trong hai luật hoặc trong nhiều luật cùng bao trùm d. ðể quyết ñịnh ñiều này, với mỗi d có wRule cRule, ta giữ nguyên cấu trúc dữ liệu dạng <dID, y, cRule, wRule>, trong ñó dID là ñịnh danh của mẫu d, y là lớp của d. Gọi A là tập <dID, y, cRule, wRule>, U là tập tất cả các cRule, và Q là tập các cRule có ưu tiên cao hơn các wRule tương ứng. Giai ñoạn này của thuật toán ñược biểu diễn như sau:
1 Q = Ø; U = Ø; A = Ø; 2 for each case d ∈D do
3 cRule = maxCoverRule(Cc,d); 4 wRule = maxCoverRule(Cw,d); 5 U = U ∪ {cRule};
6 cRule.classCasesCovered[d.class]++; 7 if cRule wRule then
8 Q = Q ∪ {cRule};
9 mark cRule;
11 end
Hàm maxCoverRule tìm luật ưu tiên cao nhất chứa mẫu d. Cc (hoặc Cw) là tập luật có cùng (hoặc khác) lớp với d. d.id và d.class biểu diễn ñịnh danh và lớp của d tương ứng. Với mỗi cRule, ta cũng nhớ có bao nhiêu mẫu chứa nó trong mỗi lớp sử
dụng trường classCasesCovered của luật.
Giai ñoạn 2. với mỗi mẫu d mà ta không thể quyết ñịnh luật nào chứa nó trong giai ñoạn 1, ta xem lại d ñể tìm ra tất cả các luật phân lớp nó sai và có ưu tiên cao hơn cRule của tương ứng (dòng 5 trong thuật toán).
1 for each entry <dID,y,cRule,wRule> ∈ A do
2 if wRule is marked then
3 cRule.classCasesCovered[y]--; 4 wRule.classCasesCovered[y]++;
5 else wSet = allCoverRules(U,dID.case,cRule);
6 for each rule w ∈ wSet do
7 w.replace = w.replace ∪{<cRule,dID,y>};
8 w.classCasesCovered[y]++;
9 End
10 Q = Q ∪ wSet;
11 end
12 end
Nếu wRule ñược ñánh dấu (nghĩa là cRule của mẫu ít nhất), khi ñó rõ ràng wRule sẽ chứa mẫu biểu diễn bởi dID. ðiều này thỏa mãn hai ñiều kiện. Số mẫu dữ
liệu gồm cả cRule và wRule cần ñược cập nhật (dòng 3-4). Dòng 5 tìm tất cả các luật phân lớp sai mẫu dID và có ưu tiên cao hơn cRule của nó (chú ý ta chỉ sử dụng luật trong U). ðiều này ñược thực hiện bởi hàm allCoverRules. Các luật trả lại là những luật có thể thay thế cRule ñể bao trùm mẫu vì chúng có ưu tiên cao hơn. Ta ñưa thông tin này vào trường replace của mỗi luật (dòng 7). Dòng 8 gia tăng số lượng của w.classCasesCovered[y] ñể chỉ ra rằng luật w có thể bao trùm mẫu. Q bao gồm tất cả
các luật ñược sử dụng ñể xây dựng bộ phân lớp.
Giai ñoạn 3. Chọn một tập luật cuối cùng ñể ñược bộ phân lớp. Bao gồm 2 bước:
Bước 1 (dòng 1-17): chọn tập các luật tiềm năng ñể thu ñược bộ phân lớp. Trước hết sắp xếp Q theo quan hệ “ ”. ðiều này bảo ñảm rằng ñiều kiện 1 ở trên thỏa mãn trong lựa chọn luật cuối cùng. Dòng 1 và 2 là khởi tạo. Hàm compClassDistr ñếm
số mẫu huấn luyện mỗi lớp trong dữ liệu huấn luyện ban ñầu. rulErrors ghi số lỗi của các luật lựa chọn trong dữ liệu huấn luyện.
Trong dòng 5: nếu luật r không phân lớp ñúng mẫu dữ liệu nào trong tập huấn luyện thì loại bỏ luật r. Mặt khác r sẽ là luật của bộ phân lớp. Trong dòng 6, r sẽ thử
thay thế toàn bộ các luật trong r.replace vì r có trước chúng. Tuy nhiên nếu dID có trong luật trước ñó thì r hiện tại sẽ không thay thế rul chứa mẫu. Nếu không, r sẽ thay thế rul chứa mẫu, và cập nhật các trường classCasesCovered của r và rul.
Với mỗi luật ñã chọn, ta cập nhật ruleErrors và classDistr (dòng 10-11). Ta cũng chọn một lớp mặc ñịnh (ví dụ: defaultClass), lớp này là lớp chính trong dữ liệu huấn luyện còn lại, tính toán sử dụng classDistr (dòng 12). Sau khi chọn lớp mặc ñịnh, chúng ta cũng biết số lỗi (defaultError) trên dữ liệu huấn luyện còn lại (dòng 13). Tổng số lỗi (totalErrors) tập luật chọn trong C và lớp mặc ñịnh sẽ là ruleErrors + defaultErrors (dòng 14). Bước 2 (dòng 18-20): loại bỏ những luật có lỗi lớn hơn, và trả về bộ phân lớp C cuối cùng. 1 classDistr = compClassDistri(D); 2 ruleErrors = 0; 3 Q = sort(Q);
4 for each rule r in Q in sequence do
5 if r.classCasesCovered[r.class] ≠0 then
6 for each entry <rul,dID,y> in r.replace do
7 if the dID case has been covered by a
8 previous r then
9 r.classCasesCovered[y]--;
10 else rul.classCasesCovered[y]--;
11 rulesErrors = ruleErrors + errorsOfRule(r); 12 classDistr = update(r,classDistr);
13 defaultClass = selectDefault(classDistr); 14 totalErrors = ruleErrors + defaultErrors; 15 Insert <r,default-class,totalErrors> at end of C
16 End
17 End
18 Find the first rule p in C with the lowest totalErrors,
and then discard all the rules after p from C;
19 Add the default class associated with p to end of C; 20 Return C without totalErrors and default-class;
