TRƯỜNG ĐẠI HỌC CƠNG NGHIỆP THỰC PHẨM TP.HỒ CHÍ MINH
KHOA CÔNG NGHỆ THÔNG TIN

ĐỒ ÁN MÔN KHAI THÁC DỮ LIỆU
ĐỀ TÀI: PHÂN LỚP BAYES

GVHD:PSG.TS Vũ Thanh Nguyên
Nhóm thực hiện: Nhóm 10
1.
2.
3.
4.

Huỳnh Châu Tính
Phan Thị Nguyệt Trầm
Dương Trung Hiếu
Lê Cường Thịnh

TP.HỒ CHÍ MINH, THÁNG 11 NĂM 2021


Bảng phân công
Họ tên
Dương Trung Hiếu

MSSV
2001190529

Lê Cường Thịnh

2001191030

Phan Thị Nguyệt Trầm

2001190875

Huỳnh Châu Tín

2001190861

Mục lục

Nhiệm vụ
Tìm tại liệu, word,
powerpoint,thuyết trình
Tìm tại liệu, word,
powerpoint, Code
Tìm tại liệu, word,
powerpoint, tổng hợp
Tìm tại liệu, word,
powerpoint, code


Chương 1. Lý Thuyết Native Bayes
Trong học máy, phân loại Naive Bayes là một thành viên trong nhóm các phân loại có xác
suất dựa trên việc áp dụng định lý Bayes khai thác mạnh giả định độc lập giữa các hàm,
hay đặc trưng.
Mơ hình Naive Bayes cũng được biết đến với nhiều tên khác nhau ví dụ: Simple Bayes
hay independence Bayes hay phân loại Bayes.
Phân loại Naive Bayes được đánh giá cao khả năng mở rộng, đòi hỏi một số thơng số
tuyến tính trong số lượng các biến (các tính năng/ tố dự báo) trong nhiều lĩnh vực khác

nhau.
1. Khái niệm

Một phân loại Naive Bayes dựa trên ý tưởng nó là một lớp được dự đoán bằng các giá trị
của đặc trưng cho các thành viên của lớp đó. Các đối tượng là một nhóm (group) trong
các lớp nếu chúng có cùng các đặc trưng chung. Có thể có nhiều lớp rời rạc hoặc lớp nhị
phân.
Các luật Bayes dựa trên xác suất để dự đốn chúng về các lớp có sẵn dựa trên các đặc
trưng được trích rút. Trong phân loại Bayes, việc học được coi như xây dựng một mơ
hình xác suất của các đặc trưng và sử dụng mơ hình này để dự đốn phân loại cho một ví
dụ mới
Biến chưa biết hay cịn gọi là biến ẩn là một biến xác suất chưa được quan sát trước đó.
Phân loại Bayes sử dụng mơ hình xác suất trong đó phân loại là một biến ẩn có liên quan
tới các biến đã được quan sát. Quá trình phân loại lúc này trở thành suy diễn trên mơ hình
xác suất
Trường hợp đơn giản nhất của phân loại Naive Bayes là tạo ra các giả thiết độc lập về các
đặc trưng đầu vào và độc lập có điều kiện với mỗi một lớp đã cho. Sự độc lập của phân
loại Naive Bayes chính là thể hiện của mơ hình mạng tin cậy (belief network) trong
trường hợp đặc biệt, và phân loại là chỉ dựa trên một nút cha duy nhất của mỗi một đặc
trưng đầu vào. Mạng tin cậy này đề cập tới xác suất phân tán P(Y) đối với mỗi một đặc
trưng đích Y và P(Xi |Y) đối với mỗi một đặc trưng đầu vào Xi . Với mỗi một đối tượng,
dự đốn bằng cách tính tốn dựa trên các xác suất điều kiện của các đặc trưng quan sát
được cho mỗi đặc trưng đầu vào. Định lý Bayes: Giả sử A và B là hai sự kiện đã xảy ra.
Xác suất có điều kiện A khi biết trước điều kiện B được cho bởi:
P(A|B) = P(B|A).P(A)/P(B)


- P(A): Xác suất của sự kiện A xảy ra.
- P(B): Xác suất của sự kiện B xảy ra.
- P(B|A): Xác suất (có điều kiện) của sự kiện B xảy ra, nếu biết rằng sự kiện A đã xảy ra.

- P(A|B): Xác suất (có điều kiện) của sự kiện A xảy ra, nếu biết rằng sự kiện B đã xảy ra.

2. Mơ Hình xác xuất

Một cách trừu tượng, mơ hình xác suất cho phân loại là một mơ hình điều kiện ρ(C| ,.., )
Trên một lớp biến C với số lượng nhỏ các đầu ra hoặc các lớp. Điều kiện trên một vài
biến đặc trưng F1đến F2 . Vấn đề chính trong bài tốn này là nếu số đặc trưng n là lớp
hoặc một đặc trưng có thể có số lượng lớn các giá trị, thì một mơ hình được tạo ra dựa
trên các bảng xác suất là phù hợp trong điều kiện này. Lý thuyết Bayes có thể viết thành:
(C|)=
Một cách mô tả đơn giản cho công thức trên như sau:
Hậu nghiệm =
Trên thực tế, chỉ cần quan tâm tới số các phân mảnh (fraction), bởi có một số đặc trưng
không phụ thuộc vào C và các giá trị đã cho, mơ hình ρ(C|F1 ,.., Fn) có thể được viết lại
như sau, sử dụng luật xích để lặp lại định nghĩa của xác suất điều kiện:
ρ(C, ,..., ) = ρ(C) ρ( ,..., |C)
= ρ(C) ρ( |C) ρ( ,..., |C, )
= ρ(C) ρ( |C) ρ( |C, ) ρ( ,..., |C, , )
= ρ(C) ρ( |C) ρ( |C, ) …ρ( |C, , , , … )
Giả thiết của xác suất điều kiện: giả thiết rằng mỗi đặc trưng là độc lập có điều kiện với
các đặc trưng khắc với j ≠ i, trong lớp đã cho C. Điều đó có nghĩa rằng:
ρ( |C, ) = ρ( |C),
ρ( |C, , ) = ρ( |C),
ρ( |C, , , ) = ρ( |C),
Với mọi trường hợp i≠ j, k, l. Từ đó, mơ hình kết hợp được biểu diễn bởi
ρ(C| ,..., ) α ρ(C, ,..., )
α ρ(C) ρ( |C) ρ( |C) ρ( |C)…


α ρ(C)

Có nghĩa rằng dưới giả thiết độc lập trên, phân tán có điều kiện trên các lớp biến C là:
ρ(C| ,..., ) = ρ(C)
Với Z = ρ( ,..., ) được gọi là nhân tố độc lập trên ,..., và là một hằng nếu các giá trị của
các biến đặc trưng là đã biết.
3. Xây dựng phân lớp từ mô hình xác suất

Phân lớp Bayes kết hợp với luật quyết định tạo ra phân loại Naive Bayes. Một luật thông
thường đưa ra giả thuyết về khả năng nhất hay còn được xem như là cực đại hóa xác suất
hậu nghiệm (maximum a posteriori). Bộ phân loại Bayes là một hàm phân loại được định
nghĩa:

Chương 2. Bộ phân loại Naive Bayes
Naive Bayes là phương pháp phân loại dựa vào xác suất được sử dụng rộng rãi trong lĩnh
vực máy học và nhiều lĩnh vực khác như trong các cơng cụ tìm kiếm, các bộ lọc mail.
Mục đích chính là làm sao tính được xác suất Pr( , d’), xác suất để tài liệu d’nằm trong
lớp . Theo luật Bayes, tài liệu d’ sẽ được gán vào lớp nào có xác suất Pr( , d’) cao nhất
Cơng thức để tính Pr( , d’) như sau:

- TF( , d’) là số lần xuất hiện của từ wi trong tài liệu d’
- |d’| là số lượng các từ trong tài liệu d’
- wi là một từ trong không gian đặc trưng F với số chiều là |F|
- Pr(Cj ) được tính dựa trên tỷ lệ phần trăm của số tài liệu mỗi lớp tương ứng

Trong tập dữ liệu huấn luyện

Ngồi ra cịn có các phương pháp NB khác có thể kể ra như ML Naive Bayes, MAP
Naive Bayes, Expected Naive Bayes. Nói chung, Nạve Bayes là một công cụ rất hiệu
quả trong một số trường hợp.
Thuật toán Naive Bayes dựa trên nguyên lý Bayes được phát biểu như sau
=



Áp dụng trong bài toán phân loại, các dữ kiện gồm có:
- D: tập dữ liệu huấn luyện đã được vector dạng :
: phân lớp im với i = {1, 2,.., m}
Các thuộc tính độc lập điều kiện đơi một với nhau.
Theo định lý bayes :
Theo tính chất độc lập điều kiện:

Trong đó
P() Là xác suất thuộc phân lớp i khi biết trước mẫu X
P() Xác suất phân lớp i
- P() |) ): Xác suất thuộc tính thứ k mang giá trị xk khi biết X thuộc phân lớp i.
Các bước thực hiện thuật toán Naive Bayes:
Bước 1: Huấn luyện Naive Bayes (dựa vào tập dữ liệu), tính P() ) và P() |) )
Bước 2: Phân Lớp

(
Chương 3. Demo

Giả sử, như trong chương trình demo, bạn muốn dự đốn khuynh
hướng chính trị (bảo thủ hoặc phóng khống) của một người có cơng
việc là nhân viên pha chế, giới tính là nữ và thu nhập ở mức trung
bình. Bạn sẽ tính xác suất người đó là người bảo thủ và xác suất
người đó là người phóng khống, sau đó dự đốn kết quả với xác
suất cao hơn.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Threading.Tasks;
using System.Collections.Generic;
namespace Project10
{


class Class1
{
static void Main(string[] args)
{
Console.WriteLine("\nDemo phan lop Bayes");
Console.WriteLine("Muc tieu la du đoan (tu do/ phong khoang) from job, " +
"gioi tinh va thu nhap\n");
string[][] rawData = new string[30][];
rawData[0] = new string[] { "nha phan tich", "nam", "luong cao", "bao thu" };
rawData[1] = new string[] { "nhan vien coffe", "nu", "luong thap", "phong khoang" };
rawData[2] = new string[] { "Dau bep", "nam", "luong trung binh", "bao thu" };
rawData[3] = new string[] { "Bac si", "nu", "luong trung binh", "bao thu" };
rawData[4] = new string[] { "nha phan tich", "nu", "luong thap", "phong khoang" };
rawData[5] = new string[] { "Bac si", "nam", "luong trung binh", "bao thu" };
rawData[6] = new string[] { "nha phan tich", "nam", "luong trung binh", "bao thu" };
rawData[7] = new string[] { "Dau bep", "nu", "luong thap", "phong khoang" };
rawData[8] = new string[] { "Bac si", "nu", "luong trung binh", "phong khoang" };
rawData[9] = new string[] { "Dau bep", "nu", "luong thap", "phong khoang" };
rawData[10] = new string[] { "Bac si", "nam", "luong trung binh", "bao thu" };
rawData[11] = new string[] { "Dau bep", "nu", "luong cao", "phong khoang" };
rawData[12] = new string[] { "nhan vien coffe", "nu", "luong trung binh", "phong khoang" };
rawData[13] = new string[] { "nha phan tich", "nam", "luong thap", "phong khoang" };
rawData[14] = new string[] { "Bac si", "nu", "luong cao", "bao thu" };
rawData[15] = new string[] { "nhan vien coffe", "nu", "luong trung binh", "bao thu" };

rawData[16] = new string[] { "Bac si", "nam", "luong trung binh", "bao thu" };
rawData[17] = new string[] { "nhan vien coffe", "nam", "luong cao", "bao thu" };
rawData[18] = new string[] { "Bac si", "nu", "luong trung binh", "phong khoang" };
rawData[19] = new string[] { "nha phan tich", "nam", "luong thap", "phong khoang" };
rawData[20] = new string[] { "Bac si", "nam", "luong trung binh", "bao thu" };
rawData[21] = new string[] { "Dau bep", "nam", "luong trung binh", "bao thu" };


rawData[22] = new string[] { "Bac si", "nu", "luong cao", "bao thu" };
rawData[23] = new string[] { "nha phan tich", "nam", "luong cao", "bao thu" };
rawData[24] = new string[] { "nhan vien coffe", "nu", "luong trung binh", "phong khoang" };
rawData[25] = new string[] { "Bac si", "nam", "luong trung binh", "bao thu" };
rawData[26] = new string[] { "nha phan tich", "nu", "luong trung binh", "bao thu" };
rawData[27] = new string[] { "nha phan tich", "nam", "luong trung binh", "bao thu" };
rawData[28] = new string[] { "Bac si", "nu", "luong trung binh", "phong khoang" };
rawData[29] = new string[] { "nhan vien coffe", "nam", "luong trung binh", "bao thu" };
Console.WriteLine("Du lieu la: \n");
ShowData(rawData, 5, true);
Console.WriteLine("Chia du lieu 80% cho huan luyen và 20% cho thu nghiem");//Chia dữ liệu
thành 80% -20% tập huấn luyện và thử nghiệm
string[][] trainData;
string[][] testData;
MakeTrainTest(rawData, 15, out trainData, out testData); // seed = 15 is nice
Console.WriteLine("Hoàn thành\n");
Console.WriteLine("Training data: \n");
ShowData(trainData, 5, true);//hiển thị 5 dòng đầu tiên
Console.WriteLine("Test data: \n");
ShowData(testData, 5, true); // hiện thị 5 dòng cuối
Console.WriteLine("Tao doi tuong phan loai phan lop bayes");
Console.WriteLine("Phan loai huan luyen và su dung du lieu huan luyen");

BayesClassifier bc = new BayesClassifier();
bc.Train(trainData); // tính tốn cấu trúc dữ liệu đếm khóa
Console.WriteLine("Hoan thanh \n");
double trainAccuracy = bc.Accuracy(trainData);
Console.WriteLine("Do chinh xac cua mo hinh tren du lieu huan luyen = " +
trainAccuracy.ToString("F4"));
double testAccuracy = bc.Accuracy(testData);
Console.WriteLine("Do chinh xac cua mo hinh tren du lieu thu nghiem = " +


testAccuracy.ToString("F4"));
Console.WriteLine("\nCong viec = nhan vien coffe, gioi tinh = nu, "
+ "thu nhap = luong trung binh \n");
string[] features = new string[] { "nhan vien coffe", "nu", "luong trung binh" };
string phongkhoang = "phong khoang";
double pphongkhoang = bc.Probability(phongkhoang, features);
Console.WriteLine("Xac xuat phong khoang = " +
pphongkhoang.ToString("F4"));
string baothu = "bao thu";
double pbaothu = bc.Probability(baothu, features);
Console.WriteLine("Xac xuat bao thu = " +
pbaothu.ToString("F4"));
Console.WriteLine("\nHoan thanh\n");
Console.ReadLine();
} // Main
static void MakeTrainTest(string[][] allData, int seed,
out string[][] trainData, out string[][] testData)
{
Random rnd = new Random(seed);
int totRows = allData.Length;

int numTrainRows = (int)(totRows * 0.80);
int numTestRows = totRows - numTrainRows;
trainData = new string[numTrainRows][];
testData = new string[numTestRows][];
string[][] copy = new string[allData.Length][]; // bản sao tham chiếu của tất cả dữ liệu
for (int i = 0; i < copy.Length; ++i)
copy[i] = allData[i];
for (int i = 0; i < copy.Length; ++i) // thứ tự xáo trộn
{


int r = rnd.Next(i, copy.Length);
string[] tmp = copy[r];
copy[r] = copy[i];
copy[i] = tmp;
}
for (int i = 0; i < numTrainRows; ++i)
trainData[i] = copy[i];
for (int i = 0; i < numTestRows; ++i)
testData[i] = copy[i + numTrainRows];
} // MakeTrainTest
static void ShowData(string[][] rawData, int numRows, bool indices)
{
for (int i = 0; i < numRows; ++i)
{
if (indices == true)
Console.Write("[" + i.ToString().PadLeft(2) + "] ");
for (int j = 0; j < rawData[i].Length; ++j)
{
string s = rawData[i][j];

Console.Write(s.PadLeft(14) + " ");
}
Console.WriteLine("");
}
if (numRows != rawData.Length-1)
Console.WriteLine(". . .");
int lastRow = rawData.Length - 1;
if (indices == true)
Console.Write("[" + lastRow.ToString().PadLeft(2) + "] ");
for (int j = 0; j < rawData[lastRow].Length; ++j)


{
string s = rawData[lastRow][j];
Console.Write(s.PadLeft(14) + " ");
}
Console.WriteLine("\n");
}
static double[] MakeIntervals(double[] data, int numBins) // dữ liệu số bin
{
{
double max = data[0]; // tìm tối thiểu & tối đa
double min = data[0];
for (int i = 0; i < data.Length; ++i)
{
if (data[i] < min) min = data[i];
if (data[i] > max) max = data[i];
}
double width = (max - min) / numBins; // tính chiều rộng
double[] intervals = new double[numBins * 2]; // khoảng thời gian

intervals[0] = min;
intervals[1] = min + width;
for (int i = 2; i < intervals.Length - 1; i += 2)
{
intervals[i] = intervals[i - 1];
intervals[i + 1] = intervals[i] + width;
}
intervals[0] = double.MinValue; // Ngoại lệ
intervals[intervals.Length - 1] = double.MaxValue;
return intervals;
}

}

static int Bin(double x, double[] intervals)


{
for (int i = 0; i < intervals.Length - 1; i += 2)
{
if (x >= intervals[i] && x < intervals[i + 1])
return i / 2;
}
return -1; //Lỗi
}
} // Program
public class BayesClassifier
{
private Dictionary<string, int>[] stringToInt; // "nam" -> 0, etc.
private int[][][] jointCounts; // [tính năng] [giá trị] [phụ thuộc]

private int[] dependentCounts;
public BayesClassifier()
{
this.stringToInt = null; // cần dữ liệu huấn luyện để biết kích thước
this.jointCounts = null; // cần dữ liệu huấn luyện để biết kích thước
this.dependentCounts = null; // cần dữ liệu huấn luyện để biết kích thước
}
public void Train(string[][] trainData)
{
// 1. quét dữ liệu đào tạo và tạo một từ điển trên mỗi cột
int numRows = trainData.Length;
int numCols = trainData[0].Length;
this.stringToInt = new Dictionary<string, int>[numCols]; // cấp phát mảng

for (int col = 0; col < numCols; ++col) // bao gồm các giá trị y
{


stringToInt[col] = new Dictionary<string, int>(); // khởi tạo từ điển

int idx = 0;
for (int row = 0; row < numRows; ++row) // mỗi hàng của cột curr
{
string s = trainData[row][col];
if (stringToInt[col].ContainsKey(s) == false) // lần đầu tiên nhìn thấy
{
stringToInt[col].Add(s, idx); // ex: nha phan tich -> 0
++idx;
}
} // mỗi hàng

} // từng col
// 2. quét và đếm bằng cách sử dụng Từ điển stringToInt
this.jointCounts = new int[numCols - 1][][];// không bao gồm giá trị y
// Một. phân bổ thứ hai mờ
for (int c = 0; c < numCols - 1; ++c) // từng cột tính năng nhưng khơng phải cột y
{
int count = this.stringToInt[c].Count; // đánh số các giá trị có thể có cho cột
jointCounts[c] = new int[count][];
}
// NS. phân bổ thứ nguyên cuối cùng = luôn luôn là 2 để phân loại nhị phân
for (int i = 0; i < jointCounts.Length; ++i)
for (int j = 0; j < jointCounts[i].Length; ++j)
{
//int numDependent = stringToInt[stringToInt.Length - 1].Count;
//jointCounts[i][j] = new int[numDependent];
jointCounts[i][j] = new int[2]; // phân loại nhị phân
}


// NS. init số lượng khớp với 1 để làm mịn Laplacian
for (int i = 0; i < jointCounts.Length; ++i)
for (int j = 0; j < jointCounts[i].Length; ++j)
for (int k = 0; k < jointCounts[i][j].Length; ++k)
jointCounts[i][j][k] = 1;

// NS. tính toán số lượng chung
for (int i = 0; i < numRows; ++i)
{
string yString = trainData[i][numCols - 1]; // giá trị phụ thuộc
int depIndex = stringToInt[numCols - 1][yString];// chỉ mục tương ứng

for (int j = 0; j < numCols - 1; ++j)
{
int attIndex = j;
string xString = trainData[i][j]; // một giá trị thuộc tính như "nam"
int valIndex = stringToInt[j][xString]; // số nguyên tương ứng như 0
++jointCounts[attIndex][valIndex][depIndex];
}
}
// 3. quét và đếm số của từng giá trị trong số 2 giá trị phụ thuộc
this.dependentCounts = new int[2]; // nhị phân
for (int i = 0; i < dependentCounts.Length; ++i) // Đơn vị Laplacian
dependentCounts[i] = numCols - 1; // tính năng numCols - 1 = num
for (int i = 0; i < trainData.Length; ++i)
{
string yString = trainData[i][numCols - 1]; // bao thu or phong khoang
int yIndex = stringToInt[numCols - 1][yString]; // 0 or 1
++dependentCounts[yIndex];
}


return;
}
public double Probability(string yValue, string[] xValues)
{
int numFeatures = xValues.Length; // ví dụ: 3 (cơng việc, giới tính, thu nhập)
double[][] conditionals = new double[2][]; // nhị phân
for (int i = 0; i < 2; ++i)
conditionals[i] = new double[numFeatures]; // Ví dụ: P('Bac si' | bao thu)
double[] unconditionals = new double[2]; // ví dụ: P('bao thu'), P('phong khoang')
// chuyển đổi chuỗi thành int

int y = this.stringToInt[numFeatures][yValue];
int[] x = new int[numFeatures];
for (int i = 0; i < numFeatures; ++i)
{
string s = xValues[i];
x[i] = this.stringToInt[i][s];
}
// tính tốn các điều kiện
for (int k = 0; k < 2; ++k) // mỗi giá trị y
{
for (int i = 0; i < numFeatures; ++i)
{
int attIndex = i;
int valIndex = x[i];
int depIndex = k;
conditionals[k][i] =
(jointCounts[attIndex][valIndex][depIndex] * 1.0) /
dependentCounts[depIndex];
}


}
// tính tốn vơ điều kiện
int totalDependent = 0; // ví dụ: count(bao thu) + count(phong khoang)
for (int k = 0; k < 2; ++k)
totalDependent += this.dependentCounts[k];
for (int k = 0; k < 2; ++k)
unconditionals[k] = (dependentCounts[k] * 1.0) / totalDependent;
//tính tốn
double[] partials = new double[2];

for (int k = 0; k < 2; ++k)
{
partials[k] = 1.0; // bởi vì chúng ta đang nhân
for (int i = 0; i < numFeatures; ++i)
partials[k] *= conditionals[k][i];
partials[k] *= unconditionals[k];
}
// bằng chứng = tổng của các phần
double evidence = 0.0;
for (int k = 0; k < 2; ++k)
evidence += partials[k];
return partials[y] / evidence;
}// Xác suất
public double Accuracy(string[][] data)
{
int numCorrect = 0;
int numWrong = 0;
int numRows = data.Length;
int numCols = data[0].Length;
for (int i = 0; i < numRows; ++i) // hàng


{
string yValue = data[i][numCols - 1]; // giả sử y ở cột cuối cùng
string[] xValues = new string[numCols - 1];
Array.Copy(data[i], xValues, numCols - 1);
double p = this.Probability(yValue, xValues);
if (p > 0.50)
++numCorrect;
else

++numWrong;
}
return (numCorrect * 1.0) / (numCorrect + numWrong);
}
} // class BayesClassifier
} // ns


Kết luận
• Cho kết quả tốt trong thực tế mặc dù chịu những giả thiết về tính độc lập có điều
kiện (khi được cho nhãn/lớp) của các thc tính
• Phân lớp khơng u cầu phải ước lượng một cách chính xác xác suất λ dễ cài đặt,
học nhanh, kết quả dễ hiểu
• Sử dụng trong phân loại text, spam, etc
• Tuy nhiên khi dữ liệu có nhiều thuộc tính dư thừa thì nạve Bayes khơng cịn hiệu
quả
• Dữ liệu liên tục có thể khơng tn theo phân phối chuẩn (=> kernel density
estimators)


Tài liệu tham khảo
1. />%209%20CH%E1%BB%90T%20IN%288%29.pdf
2. />