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) {
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)
{
List<List<int>> listCs = new List<List<int>>(); DataTable database = decisionTable.database; List<ListPair> listPair = newList<ListPair>(); List<int> Cs = new List<int>();
List<int> Cp; List<int> Cq;
List<int> track = newList<int>();
for (int s = 0; s < numOfCondition; s++) {
Cs = decisionTable.conditionList[s];
int valueCs = Int32.Parse(database.Rows[Cs[0] - 1][attr].ToString());
if (valueCs == z && calcSupport(Cs, listW) > 0 && calcSupport(Cs, listY) > 0)
{
track.Add(s);
Cp = newList<int>(); Cq = newList<int>();
foreach (int item in decisionTable.conditionList[s]) { if (listW.Contains(item)) { Cp.Add(item); } elseif (listY.Contains(item)) { Cq.Add(item); } }
ListPair list = newListPair(); list.Cs = s;
list.indexCp = Cp; list.indexCq = Cq;
list.listCp = newList<int>(); list.listCq = newList<int>();
for (int i = 0; i < numOfDecision; i++) {
int sup = calcSupport(Cp, decisionTable.decisionList[i]); list.listCp.Add(sup);
list.listCq.Add(calcSupport(Cs,decisionTable.decisionList[i])- sup);
} listPair.Add(list); } } // Bổ sung dòng và cột Cp, Cq int count = 0;
foreach (ListPair item in listPair) {
supportMatrix[count + item.Cs] = item.listCp;
supportMatrix.Insert(count + item.Cs + 1, item.listCq); count++;
}
// 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 < listPair.Count; j++) { if (i == listPair[j].Cs) { valid = false; tmp.conditionList.Add(tmp.conditionList.Count, listPair[j].indexCp); tmp.conditionList.Add(tmp.conditionList.Count, listPair[j].indexCq);
} } 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 thô thuộc tính quyết định ở thuật toán 2.4
publicvoid unrefinedDecision(int w, int y) {
int tmpW = -1; int tmpY = -1;
DataTable database = decisionTable.database;
for (int i = 0; i < numOfDecision; i++) { int value = Int32.Parse(database.Rows[decisionTable.decisionList[i][0] - 1]["d"].ToString()); if (value == w) { tmpW = i; } if (value == y) { tmpY = i;
} }
List<int> Dz = newList<int>();
for (int i = 0; i < numOfCondition; i++) {
Dz.Add(supportMatrix[i][tmpW] + supportMatrix[i][tmpY]); }
// Xóa cột Dw và Dy, thêm cột Dz
for (int i = 0; i < numOfCondition; i++) {
supportMatrix[i][tmpW] = Dz[i]; supportMatrix[i].RemoveAt(tmpY); }
// Cập nhật DecisionTable
DecisionTable tmp = newDecisionTable();
for (int i = 0; i < decisionTable.decisionList.Count; i++) { if (i == tmpW) { decisionTable.decisionList[i].AddRange(decisionTable.decisionList[tmpY]); tmp.decisionList.Add(tmp.decisionList.Count, decisionTable.decisionList[i]); } elseif (i != tmpY) {
tmp.decisionList.Add(tmp.decisionList.Count, decisionTable.decisionList[i]); } } decisionTable.decisionList = tmp.decisionList; }
// Tính ma trận độ hỗ trợ tại thời điểm làm mịn thuộc tính quyết định ở thuật toán 2.5
publicvoid refinedDecision(List<int> listW, int w, List<int> listY, int y,
int z) {
int tmpZ = -1;
DataTable database = decisionTable.database; for (int i = 0; i < numOfDecision; i++)
{ int value = Int32.Parse(database.Rows[decisionTable.decisionList[i][0] - 1]["d"].ToString()); if (value == z) { tmpZ = i; } }
for (int i = 0; i < numOfCondition; i++) {
int supY = supportMatrix[i][tmpZ] - supW; supportMatrix[i][tmpZ] = supW;
supportMatrix[i].Insert(tmpZ + 1, supY); }
// Cập nhật DecisionTable
DecisionTable tmp = newDecisionTable();
for (int i = 0; i < decisionTable.decisionList.Count; i++) { if (i == tmpZ) { tmp.decisionList.Add(tmp.decisionList.Count, listW); tmp.decisionList.Add(tmp.decisionList.Count, listY); } else { tmp.decisionList.Add(tmp.decisionList.Count, decisionTable.decisionList[i]); } } decisionTable.decisionList = tmp.decisionList; } // Tính ma trận độ chính xác, ma trận độ phủ và trích rút luật
publicStringBuilder calcAccCov(double alpha, double gamma) {
StringBuilder tmp = new StringBuilder();
double[,] acc = newdouble[numOfCondition, numOfDecision]; double[,] cov = new double[numOfCondition, numOfDecision]; int[] supN = newint[numOfCondition];
int[] supM = newint[numOfDecision]; for (int i = 0; i < numOfCondition; i++) {
for (int j = 0; j < numOfDecision; j++) {
supN[i] += supportMatrix[i][j]; supM[j] += supportMatrix[i][j]; }
}
for (int i = 0; i < numOfCondition; i++) {
for (int j = 0; j < numOfDecision; j++) {
acc[i, j] = (double)supportMatrix[i][j] / (double)supN[i]; cov[i, j] = (double)supportMatrix[i][j] / (double)supM[j]; }
}
tmp.Append("* Ma trận độ chính xác:" + Environment.NewLine); for (int i = 0; i < numOfCondition; i++)
{
for (int j = 0; j < numOfDecision; j++) {
}
tmp.Append(Environment.NewLine); }
tmp.Append(Environment.NewLine);
tmp.Append("* Ma trận độ phủ:" + Environment.NewLine); for (int i = 0; i < numOfCondition; i++)
{
for (int j = 0; j < numOfDecision; j++) {
tmp.Append(" " + cov[i, j] + " "); }
tmp.Append(Environment.NewLine); }
for (int i = 0; i < numOfCondition; i++) {
for (int j = 0; j < numOfDecision; j++) {
if (acc[i, j] >= alpha && cov[i, j] >= gamma) {
listRules.Add(newRule { Ci = i, Dj = j }); }
} }
return tmp; }
PHẦN KẾT LUẬN
Trong thời gian nghiên cứu và thực hiện luận văn, tác giả đã đạt đƣợc một số kết quả sau:
Nghiên cứu tổng quan về khai phá dữ liệu, khai phá các luật quyết định đồng thời một số vấn đề cơ bản của lý thuyết tập thô, luật quyết định và công thức biểu diễn mối quan hệ giữa độ đo hỗ trợ, độ đo chính xác và độ đo phủ của các luật quyết định.
Nghiên cứu thuật toán theo tiếp cận gia tăng phát hiện các luật quyết định mới khi các thuộc tính trong bảng dữ liệu thay đổi.
Nghiên cứu các định lý và hệ quả làm cơ sở cho tính đúng của thuật toán theo tiếp cận gia tăng phát hiện các luật quyết định mới khi làm thô, làm mịn các giá trị thuộc tính điều kiện và khi làm thô, làm mịn các giá trị thuộc tính quyết định.
Xây dựng và cài đặt đƣợc chƣơng trình thử nghiệm khai phá các luật quyết định trên bảng dữ liệu có giá trị thuộc tính thay đổi.
Một số đề xuất
Trong thời gian tới luận văn sẽ mở rộng nghiên cứu và tiếp tục hoàn thiện để có thể áp dụng vào thực tế.
TÀI LIỆU THAM KHẢO Tài liệu tiếng Việt
1. Nguyễn Viết Cƣờng, Phùng Thị Thu Hiền, Nguyễn Quang Khanh, Phạm Quang Dũng (2009), “Một đẳng thức kép của các tập thô”, Tạp chí nghiên cứu Khoa học kỹ thuật và công nghệ quân sự.
2. Phùng Thị Hiền, Lê Quang Hào, Nguyễn Quang Khanh, Nguyễn Bá Tƣờng (2010), “Định nghĩa tập thô theo hàm thuộc thô”, Tạp chí nghiên cứu Khoa học kỹ thuật và công nghệ quân sự.
3. Nguyễn Quang Khanh, Nguyễn Bá Tƣờng (2011), “Thuật toán xác định giá trị ngƣỡng dựa trên mô hình dự đoán biến tập thô”, Tạp chí nghiên cứu Khoa học kỹ thuật và công nghệ quân sự.
4. Nguyễn Quang Khanh, Nguyễn Bá Tƣờng (2011), “Một cách tiếp cận mới để học gia tăng các luật quyết định”, Tạp chí Công nghệ thông tin & truyền thông, các công trình nghiên cứu, phát triển và ứng dụng công nghệ thông tin và truyền thông.
5. Nguyễn Đăng Khoa (2003), Nghiên cứu một vài khía cạnh của lý thuyết tập thô và ứng dụng, Luận án Tiến sĩ toán học, Trƣờng Đại học Bách khoa Hà Nội.
6. Nguyễn Thanh Thủy (2003), Phát hiện tri thức và khai phá dữ liệu: Công cụ, phương pháp và ứng dụng, Bài giảng Trƣờng Thu, Hà Nội.
7. Nguyễn Hữu Trọng (2008), Phát triển một số thuật toán khai phá luật kết hợp trên cơ sở dữ liệu gia tăng, Luận án Tiến sĩ Toán học, Viện Công nghệ thông tin, Viện Khoa học và Công nghệ Việt Nam.
Tài liệu tiếng Anh
8. Bang, W., Bien, Z. (1999), “New incremental learning algorithm in the frame work of rough set theory”, International Journal of Fuzzy Systems.
9. Bian, X. (1998), “Certain rule learning of the inconsistent data”, Journal of East China Shipbuilding Institute.
10. Chan, C. (1998), “A rough set approach to attribute generalization in dât mining”, Inf. Sci.
11. Chen, H., Li, T., Qiao S., Ruan D. (2010), “A Rough Set based dynamic maintenance approach for approximations in coarsening and refining attribute values”, International journal of intelligent systems.
12. Pawlak, Z. (1982), “Rough sets”, International Journal of Computer and Information Science.
13. Pawlak, Z. (1991), Rough sets: Theoretical Aspects of Reasoning about Data, Kluwer Academic Publisher, London.
14. Tong, L., An (2002), “Incremental learning of decision rules based on rough set theory”, Proceedings of the World Congress on Intelligent Control and Automation.