TRƯỜNG ĐẠI HỌC QUY NHƠN

KHOA CÔNG NGHỆ THÔNG TIN

-----🙞🙜🕮🙞🙜-----

BÁO CÁO THỰC HÀNH LÀM VIỆC NHÓM

TÌM HIỂU VỀ HỌC MÁY,

THUẬT TOÁN DECISION TREE, GITHUB

Giảng viên: ThS. Lê Thị Xinh

Nhóm sinh viên: Nhóm 3

Họ và tên Mã sinh viên Lớp

Phan Huỳnh Tố Hằng 4451050816 CNTT44E

Lê Đình Nhật 4451050914 CNTT44E

Lê Trọng Công 4451050774 CNTT44E

Bùi Tấn Sang 4451050948 CNTT44E

Bình Định, Tháng 10 năm 2023

 MỤC LỤC

CHƯƠNG 1. HỌC MÁY............................................................................................

1.1. Khái niệm...............................................................................................................

1.2. Mô hình chung của học máy.................................................................................

1.3. Phân loại học máy..................................................................................................

1.3.1. Học có giám sát.............................................................................................

1.3.2. Học không giám sát.......................................................................................

1.3.3. Học bán giám sát...........................................................................................

1.3.4. Học tăng cường.............................................................................................

1.4. Ứng dụng của học máy..........................................................................................

CHƯƠNG 2 THUẬT TOÁN CÂY QUYẾT ĐỊNH (DECISION TREE)………

9

2.1. Khái niệm...............................................................................................................

2.2. Các thuật toán......................................................................................................

2.2.1. Thuật toán ID3..............................................................................................

2.2.1.1. Thuật Toán............................................................................................

2.2.1.2. Tiêu chuẩn chọn thuộc tính của ID3.....................................................

2.2.1.3. Các đặc điểm của ID3...........................................................................

2.2.1.4. Training error và test error....................................................................

 2.2.2. Thuật toán C4.5.............................................................................................

2.2.3. Một số thuật toán khác..................................................................................

2.3. Phép đo..................................................................................................................

2.3.1. Entrophy........................................................................................................

2.3.2. Information Gain...........................................................................................

2.4. Tiêu chuẩn dừng....................................................................................................

2.5. Ưu và nhược điểm.................................................................................................

2.5.1. Ưu điểm.........................................................................................................

2.5.2. Nhược điểm...................................................................................................

CHƯƠNG 3. GIT & GITHUB..................................................................................

3.1. Giới thiệu..............................................................................................................

3.2. Quy trình làm việc của Git.................................................................................

3.3. Tính năng của Git…………………………………………………………...

22

3.3.1. Repository - Kho lưu trữ...............................................................................

3.3.2. Snapshot........................................................................................................

3.3.3. Commit..........................................................................................................

3.3.4. Clone.............................................................................................................

3.3.5. Push...............................................................................................................

3.3.6. Fetch..............................................................................................................

3.3.7. Pull................................................................................................................
 3.3.8 Branch – Nhánh.............................................................................................

3.4. Làm quen với Github..........................................................................................

3.4.1. Tạo một repository trên GitHub....................................................................

3.4.2. Fork một repository.......................................................................................

3.4.3. Chỉnh sửa code..............................................................................................

3.4.4. Tạo một branch trên Github..........................................................................

3.4.5. Github Flow..................................................................................................

3.5. Lợi ích của GitHub với lập trình viên...............................................................

CHƯƠNG 4. BÀI TOÁN THỰC NGHIỆM............................................................

4.1. Trình bày bài toán...............................................................................................

4.2. Thực nghiệm........................................................................................................

4.2.1 Mô tả chương trình demo...............................................................................

4.2.2 Mô tả kết quả dự đoán....................................................................................

4.2.3 Chương trình demo........................................................................................

4.2.3.1. Đọc dữ liệu mẫu huấn luyện.................................................................

4.2.3.2. Chuyển đổi dữ liệu sang dạng int..........................................................

4.2.3.3. Huấn luyện mô hình..............................................................................

4.2.3.4. Dự đoán kết quả và hiển thị cây quyết định..........................................

4.2.3.5. Hệ luật của cây quyết định....................................................................

 CHƯƠNG 1. HỌC MÁY
1.1. Khái niệm

Học máy (Machine Learning) là một lĩnh vực trong trí tuệ nhân tạo tập trung
vào việc phát triển các thuật toán và mô hình máy tính, có khả năng học và tự điều
chỉnh dựa trên dữ liệu mẫu (Training Data) hoặc dựa vào kinh nghiệm (những gì
đã được học) mà không cần phải lập trình cụ thể cho từng nhiệm vụ. Mục tiêu
chính của học máy là cho phép máy tính nhận biết các mẫu, tìm ra các quy luật, và
đưa ra dự đoán hoặc quyết định dựa trên dữ liệu đầu vào.

Các mô hình ML yêu cầu lượng dữ liệu đủ lớn để "huấn luyện" và đánh giá mô
hình. Học máy ngày càng mang tính phổ biến trên toàn thế giới. Sự tăng trưởng
vượt bậc của dữ liệu lớn (Big Data) và các thuật toán Machine Learning đã cải
thiện độ chính xác của những mô hình và dự đoán tương lai.

Bài toán Machine Learning thường được chia làm hai loại:

- Dự đoán (Prediction): dự đoán thời tiết, dự đoán điểm số học sinh,..

- Phân loại (classification): phân loại tin tức, phân loại ứng dụng,..

1.2. Mô hình chung của học máy

- Data collection – thu thập dữ liệu: Để máy tính có thể học được ta cần có một
bộ dữ liệu (dataset), ta có thể tự thu thập chúng hoặc lấy các bộ dữ liệu đã được
công bố trước đó. Lưu ý là ta phải thu thập từ nguồn chính thống, có như vậy dữ
liệu mới chính xác và máy có thể học một cách đúng đắng và đạt hiệu quả cao hơn.

- Preprocessing – tiền xử lý: Dùng để chuẩn hóa dữ liệu, loại bỏ các thuộc tính
không cần thiết, gán nhãn dữ liệu, mã hóa một số đặc trưng, trích xuất đặc trưng,
rút gọn dữ liệu nhưng vẫn đảm bảo kết quả… Bước này tốn thời gian nhất tỉ lệ
thuận với số lượng dữ liệu ta có. Thu thập dữ liệu và tiền xử lý thường chiếm hơn
70% tổng thời gian thực hiện.

- Training model – huấn luyện mô hình: Ta huấn luyện cho mô hình hay chính là
cho nó học trên dữ liệu bạn đã thu thập và xử lý ở trên.

- Evaluating model – đánh giá mô hình: Sau khi đã huấn luyện mô hình xong,
chúng ta cần dùng các độ đo để đánh giá mô hình, tùy vào từng độ đo khác nhau
mà mô hình cũng được đánh giá tốt hay không khác nhau. Độ chính xác của mô
hình đạt trên 80% được cho là tốt.

- Improve – cải thiện: Sau khi đã đánh giá mô hình, các mô hình đạt độ chính
xác không tốt thì cần được huấn luyện và đánh giá lại cho đến khi đạt độ chính xác
như kỳ vọng. Tổng thời gian của từ lúc huấn luyện đến lúc cải thiện rơi vào khoảng
30% tổng thời gian thực hiện

1.3. Các loại học máy

1.3.1 Học có giám sát

Học có giám sát (Supervised Learning) là một trong những loại phổ biến nhất
của học máy (machine learning) và đề cập đến quá trình đào tạo mô hình máy tính
để dự đoán hoặc phân loại dữ liệu dựa trên một tập dữ liệu đào tạo có nhãn. Điểm
chính của học có giám sát là có sự hướng dẫn trong quá trình học, tức là mô hình
được cung cấp với các ví dụ có nhãn để học từ chúng.

Học máy có giám sát có các thuật toán như sau: Cây quyết định (Decision
Trees), Phân loại Bayes (Naïve Bayes Classification), Hồi quy tuyến tính
(Ordinary Least Squares Regression), Hồi quy logistic (Logistic Regression),
Support Vector Machines (SVM), Kết hợp các phương pháp (Ensemble
Methods)...
 Học có giám sát tiếp tục chia nhỏ thành hai loại chính:

- Phân loại (Classification)

- Hồi quy (Reggression)

1.3.2. Học không giám sát

Học không giám sát (Unsupervised Learning) là một trong những phân nhóm
chính của học máy và đề cập đến quá trình đào tạo mô hình máy tính để hiểu cấu
trúc hoặc thông tin ẩn trong dữ liệu mà không yêu cầu dữ liệu đào tạo có nhãn như
trong học có giám sát. Trong học không giám sát, mô hình phải tự học từ dữ liệu
và tìm ra cấu trúc, mẫu, hoặc thông tin tiềm ẩn trong dữ liệu đó.

Học máy không giám sát có các thuật toán như: Thuật toán gom cụm
(Clustering Algorithms), Phân tích thành phần chính (Principal Component
Analysis - PCA), Singular Value Decomposition, Phân tích thành phần độc lập
(Independent Component Analysis)...

Học không giám sát còn được tiếp tục chia nhỏ thành hai loại:

- Phân nhóm (Clustering)

- Kết hợp (Association)

1.3.3. Học máy bán giám sát

Học máy bán giám sát (Semi-Supervised Learning) là một dạng của học máy
nằm giữa hai dạng chính là học máy có giám sát (Supervised Learning) và học máy
không giám sát (Unsupervised Learning). Trong học máy bán giám sát, mô hình
được đào tạo sử dụng cả dữ liệu có nhãn và dữ liệu không có nhãn để thực hiện
một nhiệm vụ cụ thể, thường là dự đoán hoặc phân loại.
Học máy bán giám sát có các thuật toán: Thuật toán cực đại kì vọng (EM),
SVM truyền dẫn (TSVM), Self-training, Co-training, Phương pháp dựa trên đồ thị
(Graph-based)...
 Các bài toán học máy thuộc vào nhóm này thì việc thu thập dữ liệu có nhãn tốn
rất nhiều thời gian và có chi phí cao. Ngược lại, dữ liệu chưa có nhãn có thể được
thu thập với chi phí thấp từ internet.
1.3.4. Học máy học tăng cường và ứng dụng
Học máy học tăng cường (Reinforcement Learning) là một phân nhóm trong
lĩnh vực học máy, nơi mà một hệ thống máy tính được đào tạo để tương tác với
môi trường và học thông qua các trải nghiệm. Học máy học tăng cường giống như
việc đào tạo một máy tính để thực hiện các hành động và quyết định tối ưu hóa
mục tiêu nào đó thông qua thử nghiệm và sai lầm trong môi trường.
Học máy học tăng cường có các thuật toán: Self Training, Generative models,
S3VMs, Graph-Based Algorithms, Multiview Algorithms…
Hiện tại, học tăng cường chủ yếu được áp dụng vào Lý Thuyết Trò Chơi (Game
Theory), các thuật toán cần xác định nước đi tiếp theo để đạt được điểm số cao
nhất.
1.4. Ứng dụng của học máy

Học máy được ứng dụng cực kỳ nhiều trong đời sống hiện nay trong mọi lĩnh
vực: Tài chính - ngân hang, Sinh học, Nông nghiệp, Tìm kiếm, trích xuất thông tin,
Tự động hóa, Robotics, Hóa học, Mạng máy tính, Khoa học vũ trụ, Quảng cáo, Xử
lý ngôn ngữ tự nhiên, Thị giác máy tính

Học máy có thể giúp chúng ta:

- Giải quyết nhiều vấn đề trong thị giác máy, nhận dạng giọng nói và robot.
- Khai thác dữ liệu (từ cơ sở dữ liệu lớn/trực tuyến).
- Sản xuất máy tự động thích ứng.
- Xử lý dữ liệu lớn.
 CHƯƠNG 2. THUẬT TOÁN CÂY QUYẾT ĐỊNH
(DECISSION TREE)
2.1. Khái niệm Cây quyết định (Decision Tree)

Cây quyết định (Decision Tree) là một cây phân cấp có cấu trúc được dùng để
phân lớp các đối tượng dựa vào dãy các luật. Các thuộc tính của đối tượng có thể
thuộc các kiểu dữ liệu khác nhau như Nhị phân (Binary) , Định danh (Nominal),
Thứ tự (Ordinal), Số lượng (Quantitative) trong khi đó thuộc tính phân lớp phải có
kiểu dữ liệu là Binary hoặc Ordinal.

Tóm lại, cho dữ liệu về các đối tượng gồm các thuộc tính cùng với lớp (classes)
của nó, cây quyết định sẽ sinh ra các luật để dự đoán lớp của các dữ liệu chưa biết.

Ta hãy xét một ví dụ 1 kinh điển khác về cây quyết định. Giả sử dựa theo thời
tiết mà các bạn nam sẽ quyết định đi đá bóng hay không?

Những đặc điểm ban đầu là: thời tiết, độ ẩm, gió.

Dựa vào những thông tin trên, bạn có thể xây dựng được mô hình như sau:
 Mô hình cây quyết định

Dựa theo mô hình trên, ta thấy:

Nếu trời nắng, độ ẩm bình thường thì khả năng các bạn nam đi chơi bóng sẽ
cao. Còn nếu trời nắng, độ ẩm cao thì khả năng các bạn nam sẽ không đi chơi
bóng.

2.2. Các loại thuật toán Decision Tree

2.2.1. Thuật toán ID3

2.2.1.1 . Thuật toán

● Khởi đầu: nút hiện thời là nút gốc chứa toàn bộ tập dữ liệu huấn
luyện

● Tại nút hiện thời n, lựa chọn thuộc tính:

○ Chưa được sử dụng ở nút tổ tiên.

○ Cho phép phân chia tập dữ liệu hiện thời thành các tập con
một cách tốt nhất.

○ Với mỗi giá trị thuộc tính được chọn thêm một nút con bên
dưới.

○ Chia các ví dụ ở nút hiện thời về các nút con theo giá trị
thuộc tính được chọn.

● Lặp (đệ quy) cho tới khi:

○ Tất cả các thuộc tỉnh đã được sử dụng ở các nút phía trên,
hoặc

○ Tất cả ví dụ tại nút hiện thời có cùng nhãn phần loại.

 ○ Nhãn của nút được lấy theo đa số nhãn của ví dụ tại nút hiện
thời.

2.2.1.2 . Tiêu chuẩn chọn thuộc tính của ID3

● Tại mỗi nút n:

○ Tập (con) dữ liệu ứng với nút đó.

○ Cần lựa chọn thuộc tính cho phép phân chia tập dữ liệu tốt
nhất.

● Tiêu chuẩn:

○ Dữ liệu sau khi phân chia càng đồng nhất càng tốt

○ Đo bằng độ tăng thông tin (Information Gain - IG)

○ Chọn thuộc tính có độ tăng thông tin lớn nhất

○ IG dựa trên entropy của tập (con) dữ liệu Entropy

● Trường hợp tập dữ liệu s có 2 loại nhãn: đúng (+) hoặc sai (-)

Entropy(S) = - p+ log2 p+ -p_log2p_

Với: p+: % số mẫu đúng

p_: % số mẫu sai

● Trường hợp tổng quát: có C loại nhãn

c
Entropy(S) = ∑ i=1 -pilog2pi

Với: pi: % ví dụ của S thuộc loại i

2.2.1.3 . Các đặc điểm của ID3

 ● ID3 là thuật toán tìm kiếm cây quyết định phù hợp với dữ liệu
huấn luyện

● Tìm kiếm theo kiểu tham lam, bắt đầu từ cây rỗng

● Hàm đánh giá là độ tăng thông tin

● ID3 có khuynh hướng (bias) lựa chọn cây đơn giản

○ Ít nút

○ Các thuộc tính có độ tăng thông tin lớn nằm gần gốc

2.2.1.4 .Training error và test error

● Training error (lỗi huấn luyện)

○ Là lỗi đo được trên tập dữ liệu huấn luyện

○ Thường đo bằng sự sai khác giữa giá trị tính toán của mô
hình và giá trị thực của dữ liệu huấn luyện

○ Trong quá trình học ta cố gắng làm giảm tới mức tối thiểu
lỗi huấn luyện

● Test error (lỗi kiểm tra)

○ Là lỗi đo được trên tập dữ liệu kiểm tra

○ Là cái ta thực sự quan tâm

2.2.2. Thuật toán C4.5

Thuật toán C4.5 là thuật toán cải tiến của ID3.

Trong thuật toán ID3, Information Gain được sử dụng làm độ đo. Tuy nhiên,
phương pháp này lại ưu tiên những thuộc tính có số lượng lớn các giá trị mà ít
xét tới những giá trị nhỏ hơn. Do vậy, để khắc phục nhược điểm trên, ta sử
dụng độ đo Gain Ratio (trong thuật toán C4.5) như sau:
 Đầu tiên, ta chuẩn hoá information gain với trị thông tin phân tách (split
information):

Trong đó: Split Info được tính như sau:

Giả sử chúng ta phân chia biến thành n nút cón và Di đại diện cho số lượng
bản ghi thuộc nút đó. Do đó, hệ số Gain Ratio sẽ xem xét được xu hướng phân
phối khi chia cây.

Áp dụng cho ví dụ trên và với cách chia thứ nhất, ta có:

Split Info = – ((4/7)*log2(4/7)) – ((3/7)*log2(3/7)) = 0.98

Gain Ratio = 0.09/0.98 = 0.092

 Phân biệt thuật toán ID3 và C4.5:

 ID3:
ID3 sử dụng độ đo Entropy để đo độ tạp chất lượng của mỗi thuộc tính trong qúa
trình chia nhánh.
ID3 tìm thuộc tính tốt nhất để chia nhánh dựa trên độ giảm trong Entropy sau mỗi
lần chia.
ID3 có thể tạo ra các cây quyết định có chiều sâu khác nhau và không kiểm soát
được việc quá khớp (overfitting).
 C4.5:
C4.5 sử dụng độ đo Information Gain để đo độ giảm Entropy sau khi chia nhánh.
C4.5 cố gắng tìm thuộc tính tốt nhất để chia nhánh dựa trên độ giảm Information
Gain, nhưng nó cũng hỗ trợ việc xử lý dữ liệu thiếu (missing data) và thuộc tính số
(numeric attributes).
C4.5 thường tạo ra các cây quyết định có chiều sâu đồng đều hơn và kiểm soát tốt
hơn việc quá khớp so với ID3.
  Ví dụ: Phân loại cây quyết định cho việc quyết định xem một người có thể
vay một khoản vay cá nhân hay không dựa trên các yếu tố thu nhập và lịch
sử tín dụng.
Nếu chúng ta có một tập dữ liệu về người mà chúng ta muốn phân loại liệu họ có
khả năng trả vay hay không, C4.5 có thể tạo ra một cây quyết định có chiều sâu
đồng đều và cân nhắc tốt hơn về việc chia nhánh dựa trên Information Gain, trong
khi ID3 có thể tạo ra một cây có chiều sâu không đều và tập trung nhiều hơn vào
việc chia nhánh dựa trên Entropy.
2.2.3. Một số thuật toán khác

Ngoài ID3, C4.5, ta còn một số thuật toán khác như:

- Thuật toán CHAID: tạo cây quyết định bằng cách sử dụng thống kê chi-
square để xác định các phân tách tối ưu. Các biến mục tiêu đầu vào có thể
là số (liên tục) hoặc phân loại.
- Thuật toán C&R: sử dụng phân vùng đệ quy để chia cây. Tham biến mục
tiêu có thể dạng số hoặc phân loại.
- MARS
- Conditional Inference Trees

2.3. Phép đo

2.3.1. Entropy

Entropy là thuật ngữ thuộc Nhiệt động lực học, là thước đo của sự biến đổi, hỗn
loạn hoặc ngẫu nhiên. Năm 1948, Shannon đã mở rộng khái niệm Entropy sang
lĩnh vực nghiên cứu, thống kê với công thức như sau:

Với một phân phối xác suất của một biến rời rạc x có thể nhận n giá trị khác
nhau x1,x2,…,xn.

Giả sử rằng xác suất để x nhận các giá trị này là pi=p(x=xi).

Ký hiệu phân phối này là p=(p1 ,p2 ,…,pn). Entropy của phân phối này được
định nghĩa là:
 H(p)= – ∑nn=1 pi log(pi)

Giả sử bạn tung một đồng xu, entropy sẽ được tính như sau:

H = -[0.5 ln(0.5) + 0.5 ln(0.5)]

Hàm Entropy

Hình vẽ trên biểu diễn sự thay đổi của hàm entropy. Ta có thể thấy
rằng, entropy đạt tối đa khi xác suất xảy ra của hai lớp bằng nhau.

 P tinh khiết: pi = 0 hoặc pi = 1

 P vẩn đục: pi = 0.5, khi đó hàm Entropy đạt đỉnh cao nhất

2.3.2. Information Gain

Information Gain dựa trên sự giảm của hàm Entropy khi tập dữ liệu được phân
chia trên một thuộc tính. Để xây dựng một cây quyết định, ta phải tìm tất cả thuộc
tính trả về Infomation gain cao nhất.
 Để xác định các nút trong mô hình cây quyết định, ta thực hiện tính Infomation
Gain tại mỗi nút theo trình tự sau:

- Bước 1: Tính toán hệ số Entropy của biến mục tiêu S có N phần tử với N c phần
tử thuộc lớp c cho trước:

H(S)= – ∑cc=1 (Nc/N) log(Nc/N)

- Bước 2: Tính hàm số Entropy tại mỗi thuộc tính: với thuộc tính x, các điểm dữ
liệu trong S được chia ra K child node S1, S2, …, SK với số điểm trong mỗi child
node lần lượt là m1, m2 ,…, mK , ta có:

H(x, S) = ∑Kk=1 (mk / N) * H(Sk )

- Bước 3: Chỉ số Gain Information được tính bằng:

G(x, S) = H(S) – H(x,S)

Với ví dụ 2 trên, ta tính được hệ số Entropy như sau:

EntropyParent = -(0.57*ln(0.57) + 0.43*ln(0.43)) = 0.68

Hệ số Entropy theo phương pháp chia thứ nhất:

Entropyleft = -(.75*ln(0.75) + 0.25*ln(0.25)) = 0.56

Entropyright = -(.33*ln(0.33) + 0.67*ln(0.67)) = 0.63

Ta có thể tính hệ số Information Gain như sau:

Information Gain = 0.68 – (4*0.56 + 3*0.63)/7 = 0.09

Hệ số Entropy với phương pháp chia thứ hai như sau:

Entropyleft = -(.67*ln(0.67) + 0.33*ln(0.33)) = 0.63

Entropymiddle = -(.5*ln(0.5) + 0.5*ln(0.5)) = 0.69
Entropyright = -(.5*ln(0.5) + 0.5*ln(0.5)) = 0.69

Hệ số Information Gain:
Information Gain = 0.68 – (3*0.63 + 2*0.69 + 2*0.69)/7 = 0.02

So sánh kết quả, ta thấy nếu chia theo phương pháp 1 thì ta được giá trị hệ số
Information Gain lớn hơn gấp 4 lần so với phương pháp 2. Như vậy, giá trị thông
tin ta thu được theo phương pháp 1 cũng nhiều hơn phương pháp 2.

2.4. Tiêu chuẩn dừng

Trong các thuật toán Decision tree, với phương pháp chia trên, ta sẽ chia mãi
các node nếu nó chưa tinh khiết. Như vậy, ta sẽ thu được một tree mà mọi điểm
trong tập huấn luyện đều được dự đoán đúng (giả sử rằng không có hai input giống
nhau nào cho output khác nhau). Khi đó, cây có thể sẽ rất phức tạp (nhiều node)
với nhiều leaf node chỉ có một vài điểm dữ liệu. Như vậy, nhiều khả
năng overfitting sẽ xảy ra.

Để tránh trường hợp này, ta có thể dừng cây theo một số phương pháp sau đây:

- Nếu node đó có entropy bằng 0, tức mọi điểm trong node đều thuộc một
class.
- Nếu node đó có số phần tử nhỏ hơn một ngưỡng nào đó. Trong trường hợp
này, ta chấp nhận có một số điểm bị phân lớp sai để tránh overfitting. Class
cho leaf node này có thể được xác định dựa trên class chiếm đa số trong
node.
- Nếu khoảng cách từ node đó đến root node đạt tới một giá trị nào đó. Việc
hạn chế chiều sâu của tree này làm giảm độ phức tạp của tree và phần nào
giúp tránh overfitting.
- Nếu tổng số leaf node vượt quá một ngưỡng nào đó.
- Nếu việc phân chia node đó không làm giảm entropy quá nhiều (information
gain nhỏ hơn một ngưỡng nào đó).

Ngoài ra, ta còn có phương pháp cắt tỉa cây:

 - Chia dữ liệu thành hai phần: huấn luyện và kiểm tra

- Tạo cây đủ lớn trên dữ liệu huấn luyện

- Tính độ chính xác của cây trên tập kiểm tra

- Loại bỏ cây con sao cho kết quả trên dữ liệu kiểm tra được cải thiện nhất

- Lặp lại cho đến khi không còn cải thiện được kết quả nữa

2.5. Ưu và nhược điểm

2.5.1. Ưu điểm

Cây quyết định là một thuật toán đơn giản và phổ biến. Thuật toán này được sử
dụng rộng rãi bới những lợi ích của nó:

- Mô hình sinh ra các quy tắc dễ hiểu cho người đọc, tạo ra bộ luật với mỗi
nhánh lá là một luật của cây.

- Dữ liệu đầu vào có thể là là dữ liệu missing, không cần chuẩn hóa hoặc tạo
biến giả

- Có thể làm việc với cả dữ liệu số và dữ liệu phân loại

- Có thể xác thực mô hình bằng cách sử dụng các kiểm tra thống kê

- Có khả năng là việc với dữ liệu lớn

2.5.2. Nhược điểm

- Mô hình cây quyết định phụ thuộc rất lớn vào dữ liệu của bạn. Thạm chí, với
một sự thay đổi nhỏ trong bộ dữ liệu, cấu trúc mô hình cây quyết định có thể
thay đổi hoàn toàn.
- Cây quyết định hay gặp vấn đề overfitting
 CHƯƠNG 3. GIT & GITHUB

3.1. Giới thiệu

Git là một hệ thống quản lý phiên bản (Version Control System - VCS) phổ
biến được sử dụng để theo dõi, quản lý và kiểm soát các phiên bản của mã nguồn
trong dự án phần mềm. Git được phát triển bởi Linus Torvalds vào năm 2005 và
nhanh chóng trở thành một công cụ quản lý mã nguồn phổ biến trong cộng đồng
phát triển phần mềm. Git cho phép các nhóm phát triển làm việc cùng nhau trên
cùng một dự án một cách hiệu quả. Git lưu trữ lịch sử của tất cả các thay đổi trong
mã nguồn, cho phép bạn quay lại phiên bản trước đó, hợp nhất các nhánh khác
nhau của mã, và theo dõi sự thay đổi của từng tập tin trong dự án.

GitHub là một dịch vụ nổi tiếng cung cấp kho lưu trữ mã nguồn Git cho các
dự án phần mềm. Github có đầy đủ những tính năng của Git, ngoài ra nó còn bổ
sung những tính năng về social để các developer tương tác với nhau. Là công cụ
giúp quản lý source code tổ chức theo dạng dữ liệu phân tán, giúp đồng bộ source
code của team lên 1 server. Giao diện của GitHub rất thân thiện với người dùng để
ngay cả những lập trình viên mới làm quen cũng có thể tận dụng Git. Nếu không
có GitHub, việc sử dụng Git thường yêu cầu hiểu biết về kỹ thuật và sử dụng dòng
lệnh nhiều hơn.

Các thuật ngữ cơ bản:

 - git: là prefix của các lệnh được sử dụng dưới CLI.
- branch: được hiểu như là nhánh, thể hiện sự phân chia các version khi 2
version đó có sự sai khác nhất định.
- commit: là một điểm trên cây công việc (Work Tree) hay gọi là cây phát
triển công việc.
- clone: nhân bản, hay thực hiện nhân bản. Sử dụng để clone các project,
repository trên các hệ thống chạy trên cơ sở là git. Việc clone này sẽ sao
chép repository tại commit mình mong muốn, dùng để tiếp tục phát triển.
Thao tác này sẽ tải toàn bộ mã nguồn, dữ liệu về máy tính của bạn.
- folk: thao tác thực hiện sao chép repository của chủ sở hữu khác về git
account của mình, sử dụng và đối xử như 1 repository do mình tạo ra.
- repository: kho quản lý dữ liệu, là nơi lưu trữ các dữ liệu, mã nguồn của
project.
- tag: sử dụng để đánh dấu một commit khi bạn có quá nhiều commit tới mức
không thể kiểm soát được.
- remote: sử dụng để điều khiển các nhánh từ một repository trên git server,
đối xử với các nhánh trên remote tương tự như đối xử với các nhánh trên
local.
- diff: So sánh sự sai khác giữa phiên bản hiện tại với phiên bản muốn so sánh,
nó sẽ thể hiện các sự khác nhau.
- gitignore: file mặc định của git sử dụng để loại bỏ các thư mục, file mà mình
không muốn push lên git server.

3.2. Quy trình làm việc của Git

Có ba thành phần chính của một dự án Git: các kho lưu trữ, cây làm việc và chỉ
mục.
- Kho lưu trữ, hay repo, là “thùng chứa” theo dõi tất cả các thay đổi đối với
các tệp dự án, chứa tất cả các cam kết được thực hiện bởi nhóm của bạn.
Bạn có thể truy cập vào lịch sử cam kết với lệnh nhật ký git.
- Cây làm việc hoặc thư mục làm việc bao gồm các tệp bạn đang làm việc -
một hệ thống tệp nơi bạn có thể xem và sửa đổi các tệp của mình.
- Chỉ mục hoặc khu vực sắp xếp, là nơi các cam kết được chuẩn bị. Sau khi
được sắp xếp, các tệp từ cây làm việc được so sánh với các tệp trong kho lưu
trữ. Các thay đổi đối với tệp trong cây làm việc được đánh dấu là đã sửa đổi
trước khi thực hiện chúng.

Trong Git, các tệp có thể tồn tại trong ba trạng thái chính:

- Trạng thái đã sửa đổi (Modified): xảy ra khi sửa đổi một tệp trong dự án
nhưng chưa thêm nó vào commit. Tệp đã sửa đổi không nằm trong commit
nào và chưa được theo dõi bởi Git.
- Trạng thái đã đánh dấu (Staged): xảy ra sau khi sử dụng lệnh git add để đánh
dấu tệp hoặc thay đổi cụ thể để sẵn sàng cho việc commit. Tệp đã đánh dấu
sẽ được bao gồm trong commit tiếp theo.
 - Trạng thái đã commit (Committed): xảy ra khi sử dụng lệnh git commit để
tạo một commit với các tệp đã đánh dấu. Các tệp trong trạng thái này đã
được lưu trữ trong lịch sử của mã nguồn, có thể xem lại chúng bất kỳ lúc
nào.

3.3. Tính năng của Git

3.3.1. Repository – Kho lưu trữ

- Trong Git, Repository là nơi lưu trữ, quản lý tất cả những thông tin cần thiết
(thư mục, tập tin, ảnh, video, bảng biểu, dữ liệu… ) cũng như các sửa đổi và lịch
sử của toàn bộ dự án. Khi tạo mới repository, bạn nên tạo thêm tập tin README
hoặc một tập tin thông tin giới thiệu về dự án của bạn.
- Bạn có thể có nhiều cách tổ chức cho repository, trong lập trình C# trên Visual -
Studio, bạn có thể lưu trữ một solution trong một kho, solution đó có thể chứa
nhiều project.
- Có hai loại repository, đó là local repository và remote repository.
 Các thao tác xử lý giữa remote repository và local repository

3.3.2. Snapshot

Cơ chế lưu trữ phiên bản của Git là sau mỗi lần bạn thực hiện lưu trạng thái
(commit) sẽ tạo ra một “ảnh chụp” (snapshot) lưu lại nội dung tất cả các tập tin,
thư mục tại thời điểm đó rồi tạo tham chiếu tới snapshot đó. Để hiệu quả hơn, nếu
như tập tin không có thay đổi, Git không lưu trữ tập tin đó lại mà chỉ tạo liên kết
tới tập tin gốc đã tồn tại trước đó. Sau đó khi cần bạn hoàn toàn có thể khôi phục
và sử dụng lại một snapshot, hay còn gọi là phiên bản nào đó. Đây cũng chính là
lợi thế của Git khi nó không lưu dữ liệu mà sẽ lưu dạng snapshot, giúp tiết kiệm
không gian lưu trữ.
 Git lưu trữ dữ liệu dưới dạng ảnh chụp (snapshot) của mã nguồn dự án theo
thời
gian.

3.3.3. Commit

- Commit là thao tác báo cho hệ thống biết bạn muốn lưu lại trạng thái hiện
hành, ghi nhận lại lịch sử các xử lý như đã thêm, xóa, cập nhật các file hay thư
mục nào đó trên repository.
- Khi thực hiện commit, trong repository sẽ ghi lại sự khác biệt từ lần commit
trước với trạng thái hiện tại. Các commit ghi nối tiếp với nhau theo thứ tự thời
gian do đó chỉ cần theo vết các commit thì có thể biết được lịch sử thay đổi
trong quá khứ.

- Khi bạn thực hiện commit, hệ thống đều yêu cầu bạn phải nhập vào commit
message để ghi chú tóm tắt là trong lần commit này là bạn đã thực hiện những
thay đổi nào, có ý nghĩa thế nào,…

3.3.4. Clone

- Nếu bạn muốn có một bản sao của một kho chứa Git có sẵn, có thể là một dự
án mà bạn tham gia – thì bạn hãy thực hiện clone. Đây là điểm khác biệt của Git
so với một số hệ thống quản lý phiên bản mã nguồn khác vì clone là tạo ra một
bản sao của gần như tất cả những gì của repository mà máy chủ đang lưu trữ.
Bạn sẽ có được tất cả lịch sử đã xảy ra trên repository và hoàn toàn có thể quay
lại, undo lại từ bất kỳ thời điểm commit nào. Và một điểm nữa là nếu ổ cứng
máy chủ bị hư, bạn có thể sử dụng bất kỳ bản sao trên bất kỳ máy khách nào để
khôi phục lại trạng thái của máy chủ.

Lịch sử các thay đổi trên repository khi clone về máy cục bộ

- Bạn có thể clone từ bất kỳ kho chứa nào, nó sẽ sao chép luôn các thiết lập về
repository và sẽ tự động tạo một master branch trên máy tính của bạn.
- Có lưu ý ở đây là trên GitHub bạn có một cách khác để sao chép kho từ
người khác là bạn thực hiện fork trên repository bạn cần. Điểm khác của fork là
bạn có thể đóng góp thêm vào repository gốc bằng cách thực hiện pull request.
Khi chủ sở hữu của repository nơi bạn fork nhận được yêu cầu sẽ xem xét chỉnh
sửa của bạn, nếu thấy hay sẽ tiến hành merge nội dung chỉnh sửa của bạn vào
source gốc.

3.3.5. Push

- Lệnh push được sử dụng để đưa nội dung kho lưu trữ cục bộ lên server. Push
là cách bạn chuyển giao các commit từ kho lưu trữ cục bộ của bạn lên server.

3.3.6. Fetch

Khi ta thực hiện fetch, lệnh này sẽ truy cập vào repository trên server và kéo
toàn bộ dữ liệu mà bạn chưa có từ repository trên server về. Sau đó, bạn có thể
tích hợp dữ liệu vào branch bất kỳ lúc nào.
3.3.7. Pull

Lệnh này sẽ tự động lấy toàn bộ dữ liệu từ repository trên server và gộp vào
cái branch hiện tại bạn đang làm việc.

3.3.8. Branch – Nhánh

- Nhánh là khái niệm rất hay trong Git, với nhánh bạn có thể tách riêng các
tính năng của dự án, thử nghiệm các tính năng mới hay cũng có thể dùng nhánh
để khắc phục, hoàn chỉnh lỗi nào đó của dự án,… Khi bắt đầu khởi tạo một
repository hoặc clone một repository, bạn sẽ có một nhánh (branch) chính tên là
master, đây là branch chứa toàn bộ các mã nguồn chính trong repository. Từ
nhánh master này, trong quá trình thực hiện dự án bạn có thể rẽ thêm nhiều
nhánh khác tùy theo nhu cầu thực tế. Tất cả các nhánh đều được hệ thống lưu
lại lịch sử các lần commit trên nhánh và bạn hoàn toàn quay lại mốc commit
nào mà mình muốn.
- Một lưu ý nhỏ chỗ này là tất cả thao tác fetch, push hoặc pull mặc định thực
hiện trên nhánh hiện hành, nên bạn lưu ý nhánh mình đang thao tác là nhánh
master hay nhánh nào để tránh sai sót.

- Giả sử bạn đang làm việc trên một dự án đã có một số commit từ trước như
hình sau:

- Bạn quyết định sẽ nâng cấp dự án qua việc giải quyết vấn đề số #53 (cách
đặt mã số vấn đề theo quy ước của dự án) nên bạn sẽ tạo một nhánh mới iss53
để cho lần nâng cấp đó, bạn sẽ giải quyết vấn đề #53. Bạn sẽ tạo nhánh mới
iss53, vậy là từ lần commit C2 trong repository của bạn sẽ có 2 nhánh là master
và iss53.

- Bạn tiếp tục làm việc trên nhánh iss53 và sau đó thực hiện commit ở C3.
- Bây giờ bạn nhận được thông báo rằng có một vấn đề với dự án và bạn cần
khắc phục nó ngay lập tức. Bạn có vấn đề mình đang giải quyết (iss53) nhưng
chưa xong và lỗi mới phát hiện, cần khắc phục. Với Git, bạn không cần phải tốn
quá nhiều công sức để khôi phục lại các thay đổi trước khi bạn làm iss53 để vá
lỗi rồi làm tiếp iss53. Hoàn toàn độc lập, tất cả những gì bạn cần phải làm là
chuyển lại nhánh master và lấy lại mã lệnh ở thời điểm mình cần.

- Tuy nhiên, trước khi làm điều này, bạn nên lưu ý rằng nếu thư mục làm việc
hoặc khu vực tổ chức có chứa các thay đổi chưa được commit mà xung đột với
nhánh bạn đang làm việc, Git sẽ không cho phép bạn chuyển nhánh. Tốt nhất là
bạn nên ở trạng thái làm việc "sạch" (đã commit hết) trước khi chuyển nhánh.

- Bạn sẽ quay lại thời điểm commit mình cần, giả sử C2, lúc này thư mục làm
việc của dự án giống hệt như trước khi bạn bắt đầu giải quyết vấn đề #53 và bạn
có thể tập trung vào việc sửa lỗi. Điểm quan trọng cần ghi nhớ ở đây là Git sẽ
khôi phục lại thư mục làm việc của bạn giống như snapshot của lần commit C2.
Git sẽ tự động thêm, xóa và sửa các tập tin sao cho đảm bảo rằng thư mục làm
việc của bạn giống như lần commit C2.
- Để sửa lỗi, bạn tạo nhánh mới hotfix dựa trên nhánh master để giải quyết các
lỗi mới phát sinh và bạn giải quyết xong vấn đề với lần commit C4.

- Bạn có thể chạy để kiểm tra và chắc chắn rằng bản vá lỗi hoạt động đúng
theo ý bạn muốn rồi sau đó tích hợp nó lại nhánh chính master để triển khai
với thao tác merge. Để merge, bạn sẽ chuyển sang nhánh master trước rồi
thực hiện merge nhánh master với nhánh hotfix. Sau khi merge những cập
nhật mới của bạn bây giờ ở trong snapshot của commit C4 được trỏ tới bởi
nhánh master và bạn có thể mang đi triển khai thực tế phiên bản này.
- Lúc này, bạn cần xóa nhánh hotfix đi vì bạn không còn cần tới nó nữa,
nhánh master đã trỏ đến lần commit bạn cần là C4. Bạn đã triển khai xong bản
vá lỗi quan trọng và sẵn sàng quay lại với công việc bị gián đoạn trước đó. Bạn
sẽ chuyển sang nhánh iss53 mà bạn đang làm việc trước đó để tiếp tục giải
quyết vấn đề #53.
- Như vậy với Git, bạn hoàn toàn chủ động trong các giai đoạn của dự án mà
không làm ảnh hưởng đến tiến độ chung cũng như công việc đang thực hiện của
người khác. Ngoài cách dùng merge để tích hợp những thay đổi từ một nhánh
vào một nhánh khác bạn còn có thể sử dụng rebase.
- Rebase cũng là cách để bạn tích hợp các thay đổi từ một nhánh này sang
nhánh khác. Nhưng so với merge là gộp nhánh, tức là lấy snapshot mới nhất của
mỗi branch rồi kết hợp lại với nhau. Như vậy, mỗi khi bạn merge một feature
branch về master branch thì đơn giản là nó sẽ tạo ra một merge commit ở
master branch. Trong khi đó nếu chúng ta sử dụng rebase, ví dụ như cần tích
hợp feature branch vào nhánh master thì nó sẽ đem tất cả các thay đổi, các
commit từ nhánh feature vào nhánh branch hay nói cách khác là nó sẽ sao chép
tất cả các thay đổi từ nhánh feature đặt lên trước nhánh master lần lượt theo thứ
tự.

Vậy thì khi nào bạn dùng rebase và khi nào bạn dùng merge? Rõ ràng bạn sẽ
thấy lịch sử trên git của merge nhìn rối hơn, đặc biệt là khi bạn có nhiều nhánh
 con trong khi rebase thì bạn cho một lịch sử dễ nhìn hơn. Tuy nhiên, merge là
cách gộp nhánh an toàn, đặc biệt khi có nhiều người tham gia cùng dự án. Nó sẽ
lưu lại thật sự tất cả những gì đã diễn ra trong quá trình thực hiện dự án. Trong
khi đó, nếu bạn sử dụng rebase chủ quan, không đúng cách thì có thể mất
commit trên nhánh của người khác .

3.4. Làm quen với Github

3.4.1. Tạo một repository trên GitHub

Sau khi đăng nhập thành công, ta tạo một repository mới:

Và điền vào các thông tin chi tiết:

 3.4.2. Fork một repository

Fork là một bản sao của một repo. Fork một repo cho phép ta tự do thử nghiệm
với các thay đổi mà không ảnh hưởng đến dự án gốc.

"Fork" một repository (kho lưu trữ mã nguồn) là hành động tạo ra một bản sao
độc lập của repository đó trong tài khoản của bạn hoặc trong tổ chức của bạn trên
các dịch vụ quản lý mã nguồn như GitHub, GitLab, hoặc Bitbucket. Hành động
fork cho phép bạn sao chép toàn bộ nội dung của một repository khác vào tài
khoản của bạn để bạn có thể làm việc với nó mà không ảnh hưởng đến repository
gốc.

Dưới đây là một số tình huống thường gặp khi bạn fork một repository:

- Đóng góp vào dự án mã nguồn mở: Bạn có thể fork một repository mã nguồn
mở và sau đó tạo các chỉnh sửa hoặc tính năng mới trên bản forked của mình. Sau
khi bạn hoàn thành các thay đổi, bạn có thể đề xuất chúng cho chủ sở hữu ban đầu
của repository thông qua pull request để được hợp nhất vào phiên bản gốc.
- Phát triển riêng: Bạn có thể fork một repository để tạo ra một phiên bản của dự
án cho riêng mình, để phát triển các tính năng hoặc sửa lỗi mà bạn muốn mà không
làm ảnh hưởng đến repository gốc. Điều này thường áp dụng khi bạn muốn làm
việc trên một dự án mã nguồn mở theo cách của riêng bạn.
- Nghiên cứu và học hỏi: Forking cũng có thể được sử dụng để sao chép một dự
án mã nguồn mở để nghiên cứu và học hỏi cách mà dự án đó được xây dựng và
hoạt động. Điều này giúp bạn tìm hiểu cách các dự án lớn được triển khai và quản
lý.
- Khi bạn fork một repository, bạn trở thành người chủ của bản forked đó và có
quyền kiểm soát độc lập trên nó. Tuy nhiên, các thay đổi bạn thực hiện trên bản
forked không ảnh hưởng đến repository ban đầu cho đến khi bạn gửi pull request
để đề xuất các thay đổi được hợp nhất vào repository gốc.

3.4.3. Chỉnh sửa code

Ngoài việc là một máy chủ lưu trữ nội dung Git, GitHub còn có một trình soạn
thảo code rất tốt.
 Sau khi hoàn tất chỉnh sửa tệp, ta có thể nhấp vào tab "Preview changes" để
xem các thay đổi ta đã thực hiện.

Nếu ta chấp nhận thay đổi, thêm nhận xét giải thích những gì ta đã làm và
nhấp vào “Commit changes”.

3.4.4. Tạo một Branch trên GitHub

Trên GitHub, truy cập repo và nhấp vào nút branch "master". Ở đó ta có thể
tạo một branch mới. Nhập tên và nhấp vào Create branch... :
 3.4.5. GitHub Flow

GitHub Flow là một phương pháp quản lý luồng làm việc phổ biến được sử
dụng trên GitHub và trong nhiều dự án phát triển phần mềm. Nó tập trung vào việc
tạo ra một quy trình làm việc đơn giản, dễ quản lý và dễ triển khai. GitHub Flow
thường được sử dụng cho các dự án mã nguồn mở và các dự án phát triển phần
mềm linh hoạt.

GitHub Flow bao gồm các bước cơ bản sau:

- Tạo một nhánh mới (Branch): Khi bạn bắt đầu làm việc trên một tính năng,
sửa lỗi hoặc thay đổi nào đó, bạn tạo một nhánh mới từ nhánh chính của dự
án. Nhánh này thường được đặt tên mô tả về nhiệm vụ bạn đang thực hiện.
- Thực hiện thay đổi: Bạn thực hiện các thay đổi trong nhánh mới của bạn,
bao gồm việc thêm code, sửa lỗi hoặc thực hiện tính năng mới.
- Commit thường xuyên: Bạn thường xuyên thực hiện commit để lưu trạng
thái của dự án. Điều này giúp bạn duyệt lại các thay đổi và theo dõi lịch sử
làm việc của bạn.
 - Tạo Pull Request (PR): Khi bạn đã hoàn thành công việc trên nhánh của
mình và muốn hợp nhất vào nhánh chính, bạn tạo một Pull Request. Trong
PR, bạn mô tả chi tiết về thay đổi của bạn và đưa ra yêu cầu hợp nhất vào
nhánh chính.
- Kiểm tra và thảo luận: Người khác có thể xem xét và bình luận về Pull
Request của bạn. Trong quá trình này, bạn có thể thảo luận, điều chỉnh thay
đổi và làm việc cùng nhau để đảm bảo rằng mã nguồn hoạt động một cách
đúng đắn.
- Hợp nhất (Merge): Sau khi Pull Request của bạn đã được xem xét và chấp
nhận, bạn có thể hợp nhất nó vào nhánh chính (thường là master hoặc main).
Thay đổi của bạn đã trở thành một phần của dự án.
- Triển khai (Deployment): Sau khi Pull Request được hợp nhất, bạn có thể
triển khai mã nguồn mới vào môi trường thực tế, thường là môi trường sản
phẩm cuối cùng.
- Xóa nhánh (Cleanup): Sau khi thay đổi đã được triển khai và hợp nhất vào
nhánh chính, bạn có thể xóa nhánh làm việc của bạn để giữ cho dự án sạch
sẽ.
- GitHub Flow tập trung vào việc duyệt và hợp nhất thay đổi thường xuyên,
giúp giảm thiểu sự không chắc chắn và giảm thời gian cần thiết cho việc
triển khai. Nó là một phương pháp linh hoạt và thích hợp cho các dự án phát
triển phần mềm dựa trên Git và GitHub.

3.5. Lợi ích của Github đối với lập trình viên

- Quản lí source code dễ dàng - Chứng tỏ năng lực với nhà tuyển dụng

- Github Action, Package Registry - Tracking sự thay đổi qua các version

- Giúp cải thiện kĩ năng code - Tìm kiếm tài nguyên

- Markdown - Mở rộng mối quan hệ

CHƯƠNG 4. BÀI TOÁN THỰC NGHIỆM

1.Trình bày bài toán:

1.1. Input

Bảng tổng hợp kết quả học tập của sinh viên

MS D2 C2 B2 A2 D3 C3 B3 A3 D4 C4 B4 A4 DA
V

Trong đó mỗi dòng tương ứng với kết quả học tập của mỗi sinh viên , giá trị của các ô trong mỗi
hang bao gồm :

- MSV : mã sinh viên

- D2 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm D
- C2 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm C
- B2 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm B
- A2 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm A
- D3 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm D
- C3 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm C
- B3 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm B
- A3 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm A
- D4 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm D
- C4 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm C
 - B4 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm B
- A4 : Tổng số học phẩn 2 tín chỉ của sinh viên đạt điểm A
- DA : Xếp loại học phần đồ án của sinh viên

1.2. Output

XLTN : Kết quả xét loại tốt nghiệp(C : Trung Bình ,B : Khá ,A : Giỏi)

2. Thực nghiệm

2.1. Mô tả chương trình demo

- Mô tả các chức năng của chương trình

- Chương trình bao gồm các giao diện đồ họa

2.2. Mô tả kết quả dự đoán

- Mô tả độ chính xác của phương pháp là bn %

- Sử dụng độ đo accuracy (tham khảo trang machinelearningcoban)

2.3. Mô tả Chương trình demo

2.3.1. Đọc dữ liệu Mẫu huấn luyện

2.3.2. Chuyển đổi dữ liệu sang dạng int

2.3.3 . Huấn luyện mô hình

2.3.4 . Dự đoán kết quả và hiển thị cây quyết định
2.3.5 . Hệ luật của cây quyết định: