Mệnh đề 2.1
Độ phức tạp của thuật toán tính ma trận độ hỗ trợ tại thời điểm t là O(|U|2
).
Chứng minh:
Giả sử lực lƣợng trung bình của lớp điều kiện là | U |
m và lực lƣợng trung bình của lớp quyết định là | U |
Khi đó, để tính độ hỗ trợ của một luật cần thực hiện | U | | U |*
m n phép tính, có mn phần tử nên số phép tính cần thực hiện là | U | | U |*
m n *mn = |U|2. Do đó độ phức tạp thời gian của thuật toán này là O(|U|2)
.
Mệnh đề 2.2
Độ phức tạp thời gian của thuật toán tính ma trận độ hỗ trợ tại thời điểm t+1 khi làm thô các giá trị thuộc tính điều kiện là O(|U|2
).
Chứng minh:
Cần m(m-1)/2 phép so sánh để tìm cặp lớp tƣơng đƣơng điều kiện Cp, Cq sẽ đƣợc kết hợp thành một lớp tƣơng đƣơng điều kiện mới.
Với mỗi cặp lớp tƣơng đƣơng Cp, Cq, cần n phép cộng 2 dòng này để đƣợc dòng mới. Hơn nữa vì có |CC| cặp nên ta cần n*|CC| phép cộng.
Do vậy, cần m*(m-1)/2 + n*|CC| phép toán.
Vì |CC| m/2; m, n |U| nên |CC| |U|/2. Suy ra độ phức tạp thời gian của thuật toán là O(|U|2)
.
Mệnh đề 2.3
Độ phức tạp thời gian của thuật toán tính ma trận độ hỗ trợ tại thời điểm t+1 khi làm mịn các giá trị thuộc tính điều kiện là O(|U|2
).
Chứng minh:
Cần m phép tính để kiểm tra tất cả cá lớp tƣơng đƣơng điều kiện Cs sẽ đƣợc tách thành hai lớp tƣơng đƣơng điều kiện mới Cp, Cq.
Với mỗi lớp thỏa mãn, cần n phép tính độ hỗ trợ của mỗi luật, trong đó mỗi phép này cần | U | | U |*
m n phép so sánh, đồng thời cần n phép trừ để tính giá trị các phần tử tại cột j.
Do vậy, số phép tính cần thực hiện là: m + số lớp thỏa mãn * n*
| U | | U | *
Trong trƣờng hợp tồi nhất, số lớp thỏa mãn sẽ là m. Do đó, cần nhiều nhất là: m+m*n*| U | | U |*
m n + n = m + n + |U|2 phép toán.
Vì m, n |U|, suy ra, độ phức tạp thời gian của thuật toán là O(|U|2). (adsbygoogle = window.adsbygoogle || []).push({});
Mệnh đề 2.4
Độ phức tạp thời gian của thuật toán tính ma trận độ hỗ trợ tại thời điểm t +1 khi làm thô các giá trị thuộc tính quyết định là O(|U|).
Chứng minh:
Trƣờng hợp tồi nhất cần 2n phép tính (phép so sánh chỉ số) để tìm hai lớp quyết định đƣợc kết hợp thành lớp tƣơng đƣơng quyết định mới.
Để tính độ hỗ trợ của các luật Ci Dz cần m phép cộng. Vậy số phép tính cần thực hiện là 2n + m phép tính.
Vì m, n |U|, suy ra, độ phức tạp thời gian của thuật toán là O(|U|).
Mệnh đề 2.5
Độ phức tạp thời gian của thuật toán tính ma trận độ hỗ trợ tại thời điểm t+1 khi làm mịn các giá trị thuộc tính quyết định là O(|U|2
).
Chứng minh:
Cần kiểm tra để tìm lớp quyết định đƣợc tách thành hai lớp mới. Với mỗi lớp, cần m phép tính độ hỗ trợ và m phép trừ. Vậy cần n + m*| U | | U |* m n + m = m + n + 2 | U | n phép tính.
Vì m, n |U|, suy ra, độ phức tạp thời gian của thuật toán là O(|U|2).
Mệnh đề 2.6
Độ phức tạp thời gian của thuật toán tính ma trận độ chính xác và độ phủ là O(|U|2)
.
Để tính ma trận độ chính xác Acc cần m(n-1) phép tính tổng dòng, |U|2
phép tính để tính độ hỗ trợ và làm mn phép chia. Do vậy cần m(n-1) + |U|2 + mn phép tính (m, n là kích thƣớc ma trận độ hỗ trợ tại thời điểm t+1).
Tƣơng tự, để tính ma trận Cov cũng cần n(m-1) + |U|2
+ mn phép tính Suy ra để tính ma trận độ chính xác và ma trận độ phủ cần 4mn – m – n + 2|U|2 phép tính
Vì m, n |U|, suy ra, độ phức tạp thời gian của thuật toán là O(|U|2).
Mệnh đề 2.7
Độ phức tạp của thuật toán rút trích luật quyết định có ý nghĩa là O(|U|2).
Chứng minh:
Với mỗi phần tử Acc(Ci, Dj) hoặc Cov(Ci, Dj), ta cần 1phép so sánh ngƣỡng, có tất cả 2mn phéo so sánh.
Vì m, n |U|, nên suy ra thuật toán này có độ phức tạp thời gian O(|U|2).
Mệnh đề 2.8
Độ phức tạp thuật toán rút trích các luật quyết định có nghĩa khi làm thô, làm mịn các giá trị thuộc tính là O(|U|2
).
Chứng minh
Kết quả này đƣợc suy ra trực tếp từ kết quả các mệnh đề từ 2.1 đến mệnh đề 2.7. (adsbygoogle = window.adsbygoogle || []).push({});
Độ phức tạp không gian
Trong các thuật toán từ 2.1 đến 2.6 đƣợc trình bày ở trên, ngoài m ô nhớ để lƣu các lớp tƣơng đƣơng điều kiện và n ô nhớ để lƣu các lớp tƣơng đƣơng quyết định, ta chỉ cần thêm mn ô nhớ để lƣu một ma trận độ hỗ trợ. Do đó, thuật toán cần tất cả mn + m + n ô nhớ. Hơn nữa vì m, n |U| nên thuật toán có độ phức tạp không gian là O(|U|2
2.4. Ví dụ minh họa
Cho bảng quyết định (bảng 2.1), trong đó, C = {a1, a2, a3} là tập các thuộc tính điều kiện, D = {d} là thuộc tính quyết định.
Bảng 2.1: Ví dụ về bảng quyết định đầy đủ và nhất quán U a1 a2 a3 D U a1 a2 a3 d x1 1 1 1 0 x7 2 2 2 2 x2 1 2 1 0 x8 2 3 3 2 x3 1 2 1 0 x9 2 3 3 2 x4 1 2 1 0 x10 2 3 3 2 x5 1 2 2 1 x11 3 3 3 3 x6 2 2 1 1 x12 3 3 3 3
Giả sử tiến trình thay đổi của các giá trị thuộc tính thay đổi diễn ra trong hai trƣờng hợp nhƣ sau:
- Trƣờng hợp 1: Các giá trị {2, 3} của thuộc tính a1 đƣợc làm thô thành giá trị mới là {2} (ta kí hiệu trƣờng hợp này diễn ra từ thời điểm t đến t+1).
- Trƣờng hợp 2: Giá trị {2} của thuộc tính quyết định d đƣợc làm mịn thành hai giá trị mới {2’, 2’’} thỏa mãn f(x7, d) = f(x8, d) = 2’ và f(x9, d) = f(x10, d) = 2’’(kí hiệu trƣờng hợp này diễn ra từ thời điểm t+1 đến t+2).
Tại thời điểm t, ta có U/C = {C1, C2, …,C7} với C1 = {x1}, C2 = {x2, x3, x4}, C3 = {x5}, C4 = {x6}, C5 = {x7}, C6 = {x8, x9, x10}, C7 = {x11, x12}; U/D = {D1, D2, D3, D4} với D1 = {x1, x2, x3, x4}, D2 = {x5, x6}, D3 = {x7, x8, x9, x10} D4 = {x11, x12}. Dễ dàng tính ngay đƣợc ma trận độ hỗ trợ Sup(t) (C, D) là:
Sup(t)(C, D) = 1 0 0 0 3 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 3 0 0 0 0 2 (2.7) - Với trƣờng hợp 1: Vì ft(C6, a1) = 2 và ft(C7, a1) = 3 và aj a1, ft(C6, aj)= ft(C7, aj) = 3. Suy ra tại thời điểm t+1, hai lớp tƣơng đƣơng điều kiện C6 và C7 đƣợc kết hợp thành một lớp tƣơng đƣơng điều kiện mới, kí hiệu lớp mới này là C’6, điều này có nghĩa là: C6 C7 = C’6 (định lý 2.1).
Khi đó, j = 1, …, 4 ta có |C’6 Dj| = |C6 Dj| + |C7 Dj| Suy ra, Sup(C’6, Dj) = Sup(C6, Dj) + Sup(C7, Dj)
Do đó, dòng thứ 6 và dòng thứ 7 của ma trận độ hỗ trợ tại thời điểm t (ma trận 2.7) sẽ đƣợc kết hợp lại thành một dòng mới tƣơng ứng C’6.
Nhƣ vậy, ma trận độ hỗ trợ tại thời điểm t+1 thu đƣợc là:
Sup(t+1)(C, D) = 1 0 0 0 3 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 3 2 (2.8) - Với trƣờng hợp 2:
Vì ft+1(x7, d) = ft+1(x8, d) = 2’ nên suy ra hình thành thêm lớp tƣơng đƣơng quyết định mới là {x7, x8}, kí hiệu lớp quyết định mới này là '
3
D , tức là '
3
Mặt khác, vì ft+1(x9, d) = ft+1(x10, d) = 2’’ nên cũng hình thành thêm lớp tƣơng đƣơng quyết định mới là {x9, x10}, kí hiệu là '
4
D = {x9, x10}.
Hơn nữa, vì x7, x8, x9, x10 D3 và ft+1(D3, d) = 2, suy ra tại thời điểm t+2, D3 đƣợc tách (làm mịn) thành hai lớp tƣơng đƣơng quyết định mới là '
3
D
và ' 4
D . Suy ra cột thứ 3 của ma trận (2.8) đƣợc tách thành hai cột mới tƣơng ứng với '
3
D và '
4
D . (adsbygoogle = window.adsbygoogle || []).push({});
Do đó, để tính tổng các giá trị của các phần tử của hai cột mới này trong ma trận độ hỗ trợ, trƣớc tiên ta tính các giá trị của các phần tử trên cột thứ 3 của ma trận mới nhƣ sau:
Sup(Ci, ' 3
D ) = |Ci ' 3
D | i = 1,…,6
Suy ra, các giá trị của các phần tử trên cột 4 của ma trận mới là: Sup(Ci, '
4
D ) = Sup(Ci, D3) – Sup(Ci, ' 3
D ) i = 1,…,6 Từ đây, ta có đƣợc ma trận độ hỗ trợ tại thời điểm t+2 là:
Sup(t+2)(C, D) = 1 0 0 0 0 3 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 2 2 (2.9) Sử dụng mệnh đề 1.1 và từ (2.9), ta dễ dàng tính ngay đƣợc ma trận độ chính xác và ma trận độ phủ của tất cả các luật khi làm thô ai, sau đó làm mịn d nhƣ sau: Acc(t+2) (C, D) = 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0.2 0.4 0.4 (2.10)
Cov(t+2)(C, D) = 0.25 0 0 0 0 0.75 0 0 0 0 0 0.5 0 0 0 0 0.5 0 0 0 0 0 0.5 0 0 0 0 0.5 1 1 (2.11)
Từ (2.10) và (2.11), để mô tả tất cả các luật, ta xây dựng một bảng một chiều là các cặp giá trị (Acc(t+2)
(Ci, Dj), Cov(t+2)(Ci, Dj)) tƣơng ứng đối với luật Ci Dj (bảng 2.2).
Từ bảng (2.2), nếu chọn ngƣỡng độ chính xác = 0.6 và ngƣỡng độ phủ = 0.4, ta thu đƣợc các luật quyết định có ý nghĩa tại thời điểm t+2 là: C2
D1, C3 D2, C4 D2 và C5 D3 (các luật có dấu * trong bảng 2.2).
Bảng 2.2: Độ chính xác và độ phủ đối với mỗi luật tại thời điểm t+2
Ci Dj Độ chính xác (Acc) Độ phủ (Cov) Ci Dj Độ chính xác (Acc) Độ phủ (Cov) 1 1 1 0.25 4 1 0 0 1 2 0 0 4* 2 1 0.5 1 3 0 0 4 3 0 0 1 4 0 0 4 4 0 0 1 5 0 0 4 5 0 0 2* 1 1 0.75 5 1 0 0 2 2 0 0 5 2 0 0 2 3 0 0 5* 3 1 0.5 2 4 0 0 5 4 0 0 2 5 0 0 5 5 0 0 3 1 0 0 6 1 0 0 3* 2 1 0.5 6 2 0 0
3 3 0 0 6 3 0.2 0.5
3 4 0 0 6 4 0.4 1
CHƢƠNG 3: CÀI ĐẶT VÀ THỬ NGHIỆM 3.1. Mô tả dữ liệu
Dữ liệu đầu vào là bảng quyết định nhất quán đƣợc lƣu trữ trong một bảng trong cơ sở dữ liệu, mỗi bảng dữ liệu ứng với 1 bảng quyết định, mỗi bảng có cấu trúc nhƣ sau:
+ id: lƣu thứ tự của các bản ghi
+ a1, a2, a3,.. : lƣu dữ liệu của các cột điều kiện tƣơng ứng. + d: lƣu dữ liệu cột quyết định.
Hình 3.1: Cấu trúc bảng dữ liệu minh họa
Mỗi bảng dữ liệu sẽ đƣợc lƣu trữ trong một table của cơ sở dữ liệu, để quản lý các bảng này, ta sử dụng bảng TableMetaData, bảng này sẽ lƣu lại tên bảng, số dòng, số cột và tên bảng dữ liệu đã đƣợc lƣu trong cơ sở dữ liệu. Cấu trúc bảng này nhƣ sau:
Hình 3.3: Cấu trúc bảng TableMetaData
Hình 3.4: Dữ liệu trong bảng TableMetaData 3.2. Cấu trúc chƣơng trình
Chƣơng trình “Khai phá luật quyết định trên bảng dữ liệu có các giá trị thuộc tính thay đổi” đƣợc viết bằng ngôn ngữ C# trên bộ Visual Studio 2010 sử dụng phiên bản .Net Framewok 4.0. Yêu cầu tối thiểu của hệ thống khi sử dụng chƣơng trình:
- Cài đặt .Net Framework phiên bản 4.0 trở lên. - Hệ điều hành tối thiểu Windows XP SP2
Phiên bản .Net Framework 4.0 hỗ trợ hệ điều hành Windows XP SP3 trở lên. Để cài đặt trên Windows XP SP2, cần cài đặt thêm phần mở rộng Windows Imaging Component (WIC) trƣớc khi cài đặt .Net Framework 4.0.
Mã nguồn đã đƣợc biên dịch thành tệp thực thi .exe trên môi trƣờng Windows nên chỉ cần cài đặt bộ thƣ viện yêu cầu ở trên là có thể chạy đƣợc chƣơng trình. (adsbygoogle = window.adsbygoogle || []).push({});
a. Cấu trúc các lớp chƣơng trình
Chƣơng trình đƣợc tổ chức theo các lớp có chức năng rõ ràng, tối ƣu cho việc đọc và xử lý của các lớp khác. Việc tổ chức theo lớp giúp dễ dàng theo dõi mã nguồn và xử lý khi xảy ra lỗi. Sau đây sẽ mô tả chi tiết về cấu trúc lớp chƣơng trình và chức năng của chúng.
Mối liên hệ giữa các lớp trong chƣơng trình:
Chƣơng trình thiết kế bao gồm các lớp sau:
AssociationRules: Đây là lớp xử lý giao diện chƣơng trình, gọi tới các lớp con xử lý và hiển thị kết quả lên giao diện.
AssociationRulesTable: Lớp này lƣu trữ các thông tin về bảng quyết định bao gồm: số hàng, số cột, giá trị của thuộc tính, lớp tƣơng đƣơng điều kiện và lớp tƣơng đƣơng quyết định.
SupportMatrix: Lớp chính xử lý tính toán và lƣu trữ giá trị của ma trận độ hỗ trợ, ma trận độ chính xác, ma trận độ phủ và lớp tƣơng đƣơng khi áp dụng thay đổi trong quá trình làm mịn, làm thô giá trị
thuộc tính. Lớp này chứa toàn bộ các phƣơng thức xử lý của 7 thuật toán (từ 2.1 đến 2.7).
SqlHelper: Lớp hỗ trợ tạo kết nối với cơ sở dữ liệu SQL Server, lớp này có thể đóng gói thành thƣ viện để sử dụng cho các mục đích tƣơng tự
Ultilities: Lớp tiện ích bao gồm các phƣơng thức hỗ trợ tính toán trên tập hợp và đọc dữ liệu từ bảng cơ sở dữ liệu.
b. Hƣớng dẫn chạy chƣơng trình
Các cấu trúc sử dụng để lƣu trữ ma trận độ hỗ trợ là List. Nó là một mảng vô hƣớng trong C#, rất linh hoạt khi xử lý dữ liệu dạng mảng động. Để lƣu trữ đƣợc các lớp tƣơng đƣơng, chƣơng trình dùng đối tƣợng Dictionary, mỗi phần tử của Dictionary là một list chứa các chỉ số của đối tƣợng.
3.3. Kết quả thử nghiệm
Giao diện chính của chƣơng trình
Tính toán với dữ liệu minh họa
Hình 3.6: Tính toán với dữ liệu minh họa khi tính toán
Lựa chọn cặp giá trị cần làm thô trên lớp điều kiện
Lựa chọn đối tƣợng cần làm mịn trên lớp quyết định
Hình 3.8: Lựa chọn tập đối tƣợng cần làm mịn trên lớp quyết định 3.4. Nhận xét
Dựa trên các thuật toán (từ thuật toán 2.1 đến thuật toán 2.7), chƣơng trình đã đƣợc xây dựng để nạp bảng quyết định và các lớp tƣơng đƣơng điều kiện, các lớp tƣơng đƣơng quyết định từ đó tính đƣợc ma trận độ hỗ trợ tại thời điểm t, ma trận độ hỗ trợ tại thời điểm t+1 sau khi làm thô, làm mịn các giá trị thuộc tính điều kiện, ma trận độ hỗ trợ tại thời điểm t+2 khi làm thô, làm mịn các giá trị thuộc tính quyết định.
PHỤ LỤC
Dƣới đây là các phƣơng thức trong chƣơng trình mô tả cho 7 thuật toán:
// Tính ma trận độ hỗ trợ ở thuật toán 2.1
publicvoid calcSupportMatrix() {
List<int> tmpSupport;
for (int i = 0; i < numOfCondition; i++) {
tmpSupport = new List<int>();
for (int j = 0; j < numOfDecision; j++) { tmpSupport.Add(calcSupport(decisionTable.conditionList[i], decisionTable.decisionList[j])); } supportMatrix.Add(tmpSupport); } }
// Tính ma trận độ hỗ trợ tại thời điểm làm thô thuộc tính điều kiện ở thuật toán 2.2
publicvoid unrefinedCondition(string attr, int w, int y) { (adsbygoogle = window.adsbygoogle || []).push({});
List<List<int>> listCs = new List<List<int>>(); List<int> Cs;
List<PairEquiv> pairEquivList = new List<PairEquiv>(); PairEquiv pairEquiv;
DataTable database = decisionTable.database; int valueCp = 0;
int valueCq = 0; int check;
for (int p = 0; p < numOfCondition; p++) {
for (int q = p + 1; q < numOfCondition; q++) { valueCp = Int32.Parse(database.Rows[decisionTable.conditionList[p][0]- 1][attr].ToString()); valueCq = Int32.Parse(database.Rows[decisionTable.conditionList[q][0]- 1][attr].ToString());
if ((valueCp == w && valueCq == y) || (valueCp == y && valueCq == w))
{
check = 1;
for (int k = 0; k < decisionTable.numOfColumn-1; k++) { valueCp = Int32.Parse(database.Rows[decisionTable.conditionList[p][0]- 1]["a"+(k+1)].ToString()); valueCq = Int32.Parse(database.Rows[decisionTable.conditionList[q][0]- 1]["a"+(k+1)].ToString());
{ check = 0; break; } } if (check == 1) { pairEquiv.Cp = p; pairEquiv.Cq = q; pairEquivList.Add(pairEquiv); } } } }
foreach (PairEquiv item in pairEquivList) {
Cs = new List<int>(); for (int j = 0; j < numOfDecision; j++) { Cs.Add(supportMatrix[item.Cp][j] + supportMatrix[item.Cq][j]); } listCs.Add(Cs); } // Cập nhật các dòng Cs tƣơng ứng int track = 0; foreach (PairEquiv item in pairEquivList) {
supportMatrix[item.Cp] = listCs[track++]; }
// Xóa các dòng tƣơng ứng với Cp, Cq
track = 0;
foreach (PairEquiv item in pairEquivList) {
supportMatrix.RemoveAt(item.Cq - track); track ++;
}
// Cập nhật DecisionTable
DecisionTable tmp = newDecisionTable();
for (int i = 0; i < decisionTable.conditionList.Count; i++) {
bool valid = true;
for (int j = 0; j < pairEquivList.Count; j++) { if (i == pairEquivList[j].Cp ) { valid = false; decisionTable.conditionList[i].AddRange(decisionTable.conditionList[pairEq uivList[j].Cq]); tmp.conditionList.Add(tmp.conditionList.Count, decisionTable.conditionList[i]); } elseif (i == pairEquivList[j].Cq) {
valid = false; } } if (valid) { tmp.conditionList.Add(tmp.conditionList.Count, decisionTable.conditionList[i]); } } decisionTable.conditionList = tmp.conditionList; }
// Tính ma trận độ hỗ trợ tại thời điểm làm mịn thuộc tính điều kiện ở thuật toán 2.3
publicvoid refinedCondition(string attr, List<int> listW,int w, List<int> listY, int y, int z)