Mục lục

I.Thuật toán tìm luật phân lớp ILA...................................................1

1.Thuật toán ILA:....................................................................................................................1
2. Nhận xét:..............................................................................................................................3
II. Cài đặt thuật toán (minh họa bằng C#)........................................4
1.Cấu trúc dữ liệu:...................................................................................................................4
1.1 Record:...........................................................................................................................4
1.2 Tập các record của Table:..............................................................................................5
1.3 Tập thuộc tính của Table:..............................................................................................5
1.4 Tập các luật thu được:....................................................................................................5
2.Cài đặt:..................................................................................................................................5
2.1Thuật toán tách Table thành hai Table con theo giá trị của thuộc tính kết quả:.............5
2.2Thuật toán tìm các tổ hợp j phần tử từ tập hợp n thuộc tính của Table:.........................6
2.3Thuật toán tìm tập giá trị của một tổ hợp thuộc tính:.....................................................6
2.4Thuật toán tìm tổ hợp lớn nhất:......................................................................................7
2.5Thuật toán ILA:..............................................................................................................8
III. Các Form của chương trình với tập dữ liệu test thử...............10
Main Form:............................................................................................................................10
Step 1:....................................................................................................................................11
Step 2:....................................................................................................................................12
Step 3:....................................................................................................................................13
Step 4:....................................................................................................................................14
Step 5:....................................................................................................................................15
Step 6:....................................................................................................................................16
Step 7:....................................................................................................................................17
Step 8:....................................................................................................................................18
Step 9:....................................................................................................................................19
IV. Nhận xét và kết luận....................................................................20
1. Ưu điểm:............................................................................................................................20
2. Khuyết điểm:.....................................................................................................................20
V. Hướng phát triển...........................................................................21
VI. Tài liệu tham khảo.......................................................................21
I.Thuật toán tìm luật phân lớp ILA

1.Thuật toán ILA:

Thuật toán lặp để tìm luật phân lớp cho từng phân hoạch của tập dữ liệu mẫu.
Sau khi xác định được luật, ILA loại bỏ các mẫu liên quan khỏi tập mẫu và thêm
luật mới này vào tập luật.
Kết quả có được là một danh sách có thứ tự các luật.
Thuật toán:
Gọi a: là số thuộc tính của bảng.
r: là số record của bảng.
n: là số giá trị của thuộc tính quyết định
Bước 1:
Chia r mẫu ban đầu thành n bảng con.
Bước 2:
j = 1;
Bước 3:
Trên một bảng con đang khảo sát, chia danh sách thuộc tính thành
tổ hợp có j thuộc tính.
Bước 4:
Với mỗi tổ hợp có được, tính số lần tập giá trị của tổ hợp này xuất
hiện trong bảng con đang xét (và tập giá trị này phải không xuất
hiện trong tất cả bảng con khác của tập hợp n bảng con ban đầu).
Gọi tổ hợp đầu tiên có tập giá trị có số lần xuất hiện nhiều nhất là
Tổ hợp lớn nhất.
Bước 5:
Nếu (số lần xuất hiện của tập giá trị của Tổ hợp lớn nhất) = 0

Bài tập lớn HCG_Nhóm 17 1

 j = j +1;
goto Bước 3;
Bước 6:
Lọai bỏ các record thỏa Tổ hợp lớn nhất ra khỏi bảng con đang
xét.
Bước 7:
R: tập giá trị của Tổ hợp lớn nhất ở trên -> giá trị tương ứng của
thuộc tính quyết định.
Thêm R vào tập luật kết quả.
Bước 8:
Nếu tất cả các dòng của bảng con đã được loại bỏ: quay lại Bước 2
cho bảng con khác:
Nếu không còn bảng con nào: kết thúc
Ngược lại: quay lại Bước 4 cho bảng con đang xét (với tập record
còn lại sau khi loại bỏ ở Bước 6)

2. Nhận xét:
Nếu ta có bảng quyết định như sau:
STT Thuộc tính Kết quả
1 A Y
2 A N

 Theo bảng này thì Tổ hợp lớn nhất luôn có giá trị bằng 0, mà theo
thuật toán thì nếu tổ hợp lớn nhất có giá trị bằng 0 -> tăng số lượng phần
tử của tổ hợp lên 1, nghĩa là j = 2, như vậy thì lại vượt quá (số thuộc tính
của bảng–1)=1. Và nếu ta không tăng j và trở lại Bước 3 mà tiếp tục thực
hiện Bước 6 và Bước 7 thì ta sẽ thu được các luật giống y như bảng quyết
định ban đầu:

Bài tập lớn HCG_Nhóm 17 2

  R1: If A then Y
 R2: If A then N
 Hai luật này không mâu thuẫn nhưng nó là một kết quả vô nghĩa, không
có giá trị gì cả vì khi người ta có được A thì cũng không biết được kết
quả là Y hay N.
 Như vậy thì để tránh mất thời gian thực hiện thuật toán một cách vô ích,
chúng ta phải “đánh giá” được tập các giá trị đầu vào để quyết định có
hay không thực hiện thuật toán. Đối với bảng quyết định có ít thuộc tính
và ít số record thì việc này còn khả thi, còn nhiều thì ta không thể “đánh
giá” được và như vậy thì ta phải cho thực hiện thuật toán.
 Tuy nhiên ta có nhận xét rằng nếu ở tất cả các tổ hợp có số lượng thuộc
tính < (số lượng thuộc tính của bảng – 1) mà ta đều thu được tổ hợp lớn
nhất có giá trị bằng 0 thì kết luật tập luật = rỗng, không phải thực hiện
Bước 6 và Bước 7 để thêm những luật vô nghĩa.

II. Cài đặt thuật toán (minh họa bằng C#)

Bài tập lớn HCG_Nhóm 17 3

1.Cấu trúc dữ liệu:
1.1 Record:
public class MyListViewItem
{
private ArrayList fields;
private int cardinality;
}

1.2 Tập các record của Table:

public class ListViewItemSet
{
private ArrayList items;
private int cardinality;
}
private ListViewItemSet items;
public ListViewItemSet item1;
public ListViewItemSet item2;

1.3 Tập thuộc tính của Table:

private MyListViewItem columns;
private MyListViewItem colSet; //không kể thuộc tính kết quả

1.4 Tập các luật thu được:

public ListViewItemSet rules;

2.Cài đặt:
2.1Thuật toán tách Table thành hai Table con theo giá trị của thuộc tính
kết quả:
private void distributeTable()

Bài tập lớn HCG_Nhóm 17 4

 {
int last = this.columns.Cardinality - 1;
for (int i = 0; i < this.items.Cardinality; i++)
{
//Add this.item1, this.item2
if (this.items[i][last].Equals(this.items[0][last]))
this.item1.AddListViewItem(this.items[i]);
else
this.item2.AddListViewItem(this.items[i]);
}//end of for
this.oldItem1.CopyOf(this.item1);
}//end of function

2.2Thuật toán tìm các tổ hợp j phần tử từ tập hợp n thuộc tính của Table:
private ListViewItemSet timtaptohop(MyListViewItem cols,int count)
{
ListViewItemSet result = new ListViewItemSet();
ListViewItemSet temp = new ListViewItemSet();
if (count > cols.Cardinality)
return result;
int i,j,k;
int x = 0;
for (i = 0; i < cols.Cardinality; i++)
{
MyListViewItem item = new MyListViewItem();
if (i < (cols.Cardinality-(count-1)))
{
for (j = i; j < (i+count-1); j++)
item.AddField(cols[j]);
temp.AddListViewItem(item);
}
}//end of for i
while (x < temp.Cardinality)
{
for (k = (x + count -1); k < cols.Cardinality; k++)
{
MyListViewItem temp1 = new MyListViewItem();
temp1.CopyOf(temp[x]);
temp1.AddField(cols[k]);
result.AddListViewItem(temp1);
}//end of for k
if (count == 1)
break;
x++;
}//end of while
return result;
}//end of function

2.3Thuật toán tìm tập giá trị của một tổ hợp thuộc tính:
private ListViewItemSet timtapgiatri(MyListViewItem tohop,

Bài tập lớn HCG_Nhóm 17 5

 ListViewItemSet current)
{
int j;
int id;
ListViewItemSet result = new ListViewItemSet();
for (int i = 0; i < current.Cardinality; i++)
{
MyListViewItem item = new MyListViewItem();
for (j = 0; j < tohop.Cardinality; j++)
{
id = this.colSet.IndexOf(tohop[j]);
item.AddField(current[i][id]);
}
result.AddListViewItem(item);
}//end of for i
return result;
}//end of function

2.4Thuật toán tìm tổ hợp lớn nhất:

private MyListViewItem timtohoplonnhat(MyListViewItem tohop,
ListViewItemSet tapgiatri,
ListViewItemSet current,
ListViewItemSet other)
{
MyListViewItem result = new MyListViewItem();
ListViewItemSet temp = new ListViewItemSet();
int i,j,k;
int id;
int count;
for (i = 0; i < tapgiatri.Cardinality; i++)
{
if (this.In(tohop,tapgiatri[i],other))
{
tapgiatri[i].AddField((0).ToString());
}
else
{
count = 0;
for (j = 0; j < current.Cardinality; j++)
{
for (k = 0; k < tohop.Cardinality; k++)
{
id = this.colSet.IndexOf(tohop[k]);
if (current[j][id]
.Equals(tapgiatri[i][k]) == false)
break;
}//end of for k
if (k == tohop.Cardinality)
count++;
}//end of for j

Bài tập lớn HCG_Nhóm 17 6

 tapgiatri[i].AddField(count.ToString());
}//end of else
temp.AddListViewItem(tapgiatri[i]);
}//end of for i
result = temp[0];
for (i = 1; i < temp.Cardinality; i++)
if (Convert.ToInt32(result[tohop.Cardinality].Name) <
Convert.ToInt32(temp[i][tohop.Cardinality].Name))
result = temp[i];
return result;
}//end of function

2.5Thuật toán ILA:

public void Algorithm(ListViewItemSet currentSet,
ListViewItemSet otherSet)
{
int i,j;
string kq = currentSet[0][this.colSet.Cardinality].Name;
int max;
int chisomax;
int id;
if (this.beginItem2 == 1)
this.tohop = 1;
changeTohop:
ListViewItemSet taptohop = new ListViewItemSet();
ListViewItemSet taptohoplonnhat = new ListViewItemSet();
//tren currentSet,chia danh sach this.colSet thanh cac to hop co
(this.tohop)thuoc tinh
taptohop = this.timtaptohop(this.colSet,this.tohop);
for (i = 0 ; i < taptohop.Cardinality; i++)
{
ListViewItemSet tapgiatri = new ListViewItemSet();
tapgiatri = this.timtapgiatri(taptohop[i],currentSet);
MyListViewItem tohoplonnhat = new MyListViewItem();
tohoplonnhat = this.timtohoplonnhat(taptohop[i],
tapgiatri,currentSet,otherSet);
taptohoplonnhat.AddListViewItem(tohoplonnhat);
}//end of for i
max = Convert.ToInt32(taptohoplonnhat[0][this.tohop].Name);
chisomax = 0;
for (i = 1; i < taptohoplonnhat.Cardinality; i++)
if (Convert.ToInt32
(taptohoplonnhat[i][this.tohop].Name) > max)
{
max = Convert.ToInt32
(taptohoplonnhat[i][this.tohop].Name);
chisomax = i;
}
if (max == 0)
{
this.tohop++;

Bài tập lớn HCG_Nhóm 17 7

 if (this.tohop <= this.colSet.Cardinality)
goto changeTohop;
}
//loai bo dong cua currentSet thoa tohoplonnhat
//di kem theo taptohoplonnhat la taptohop(fields) cho nen
taptohop[chisomax] di kem voi taptohoplonnhat[chisomax]
ListViewItemSet tempSet = new ListViewItemSet();
tempSet.CopyOf(currentSet);
for (i = 0; i < currentSet.Cardinality; i++)
{
for (j = 0; j < taptohop[chisomax].Cardinality; j++)
{
id = this.colSet.IndexOf(taptohop[chisomax][j]);
if (currentSet[i][id].Equals
(taptohoplonnhat[chisomax][j]) == false)
break;
}//end for j
//loai bo dong cua this.item1 hoac this.item2
if (j == taptohop[chisomax].Cardinality)
tempSet.RemoveListViewItem(currentSet[i]);
}//end for i
currentSet.CopyOf(tempSet);
//them luat moi vao this.rules,dua vao taptohop[max] va
taptohoplonnhat[max]
MyListViewItem rule = new MyListViewItem();
j = 0;
id = this.colSet.IndexOf(taptohop[chisomax][j]);
for (i = 0; i < this.colSet.Cardinality; i++)
if (i == id)
{
rule.AddField(taptohoplonnhat[chisomax][j]);
if (j < (taptohop[chisomax].Cardinality-1))
{
j++;
id = this.colSet
.IndexOf(taptohop[chisomax][j]);
}
}
else
rule.AddField(new MyField(""));
rule.AddField(kq);
this.rules.AddListViewItem(rule);
}

III. Các Form của chương trình với tập dữ liệu test thử
stt Biển dao động Nhiều bọt biển Nước rút Kết quả
1 TB Có Rất nhanh Có sóng lớn
2 Nhiều Không Rất nhanh Không có sóng lớn
3 Nhiều Có Nhanh Có sóng lớn
4 TB Có TB Không có sóng lớn

Bài tập lớn HCG_Nhóm 17 8

5 Nhiều Có TB Có sóng lớn
6 Nhiều Có Rất nhanh Có sóng lớn
7 Nhiều Không TB Không có sóng lớn
8 TB Không Rất nhanh Không có sóng lớn
9 TB Không TB Không có sóng lớn

Bảng dữ liệu:

Main Form:

Bài tập lớn HCG_Nhóm 17 9

Bài tập lớn HCG_Nhóm 17 10
Step 1:

Bài tập lớn HCG_Nhóm 17 11

Step 2:

Bài tập lớn HCG_Nhóm 17 12

Step 3:

Bài tập lớn HCG_Nhóm 17 13

Step 4:

Bài tập lớn HCG_Nhóm 17 14

Step 5:

Bài tập lớn HCG_Nhóm 17 15

Step 6:

Bài tập lớn HCG_Nhóm 17 16

Step 7:

Bài tập lớn HCG_Nhóm 17 17

Step 8:

Bài tập lớn HCG_Nhóm 17 18

Step 9:

Đọc kết quả:

R1: Nước rút nhanh -> Có sóng lớn
R2: Biển dao động nhiều và có nhiều bọt biển -> Có sóng lớn
R3: Có nhiều bọt biển và nước rút rất nhanh -> Có sóng lớn
R4: Không có bọt biển -> Không có sóng lớn
R5: Biển dao động trung bình và nước rút trung bình -> Không có
sóng lớn

Bài tập lớn HCG_Nhóm 17 19

IV. Nhận xét và kết luận
1. Ưu điểm:
 Chương trình có giao diện tiện dụng để tương tác với người sử dụng.
 Số field của bảng quyết định (Table) được nhập và sửa đổi động khi thực
hiện chương trình.
 Dựa vào đó, tập record của Table cũng được nhập động khi thực hiện
chương trình.
 Chương trình hiển thị cho người sử dụng thấy kết quả của tất cả các bước
trong thuật toán giúp cho người sử dụng tiện theo dõi quá trình đi đến tập
luật kết quả cũng như có thể kiểm tra tính đúng đắn của thuật toán.
 Hiển thị các luật thu được dưới dạng bảng là cách hiển thị rõ ràng và ít bị
nhầm lẫn! (theo thuật toán, các luật có cùng vế phải sẽ nằm cận nhau).
 Vì ngôn ngữ lập trình sử dụng (C#) có hỗ trợ Unicode nên các thuộc tính
cũng như giá trị của các record có thể nhập bằng tiếng việt.

2. Khuyết điểm:
 Vì nhập thuộc tính theo cách động nên việc nhập giá trị cho các record
không được tự nhiên lắm vì chưa biết được số lượng thuộc tính của bảng.
 Do thời gian có hạn, đồ án chỉ cài đặt một thuật toán ILA, chưa cài đặt
thuật toán học dựa trên cây định danh để có sự so sánh hiệu quả của hai
thuật toán tìm luật phân lớp này với nhau, từ đó chọn lựa phương án tối
ưu hơn để sử dụng.

Bài tập lớn HCG_Nhóm 17 20

V. Hướng phát triển
Tiếp tục cài đặt thuật toán học dựa trên cây định danh để có cơ sở chọn lựa thuật
toán tốt, sử dụng để tìm luật phân lớp cho bảng quyết định có số lượng thuộc tính và
record lớn.

VI. Tài liệu tham khảo

[1] Chuyên đề Công nghệ tri thức và ứng dụng – GS. TSKH Hoàng Kiếm
[2] Giải một bài toán trên máy tính như thế nào – GS. TSKH Hoàng Kiếm

--THE END--

Bài tập lớn HCG_Nhóm 17 21