1.Các khái niệm bản: Cây định công cụ mạnh mẽ cho việc phân loại tiên đoán.Sự hấp dẫn của phương pháp thiết lập thích hợp với lượng lớn kiện , ngược lại với mạng Neutral định thể luật.Những luật dễ dàng diễn tả mà người hiểu chúng.Việc tạo định có nhiều ứng dụng ví dụ hệ thống thư tín cơng ty chứa đựng mơ hình mà xát tiên đốn thành viên nhóm trực trả lời cho yêu cầu định mà họ không cần quan tâm mơ hình hoạt động nào.Trong số trường hợp khác khả giải thích cho việc đưa định vấn đề yếu.Trong số ứng dụng , phân loại hay tiên đoán vấn đề quan trọng 1.1 Học định (Dicision tree learning): Là phương pháp xấp xỉ giá trị rời rạc hàm mục tiêu ( target function), hàm biểu diễn định.Những học ( learned trees) biểu diễn tập hợp luật if then để tăng tính dễ đọc cho người Những phương pháp học thể giải thuật suy diễn quy nạp thông dụng ứng dụng thành công nhiệm vụ từ việc học để chuẩn đoán bệnh y học đến việc định giá rủi ro tài kinh tế 1.2 Cây định : Cây định nút nhánh thể lựa chọn số nhiều lựa chọn nút thể định.Cây định thông thường sử dụng cho việc đạt thơng tin cho mục đính tạo định.Cây định bắt đầu với nút gốc từ user nhận hành động.Từ nút , user chia nút theo cách đệ qui theo giải thuật học định Kết cuối định nhánh thể trường hợp định hệ định 1.3 Sự thể định : Cây định phân chia trường hợp việc xắp xếp từ nút gốc đến nút Điều đưa phân loại cho trường hợp Mỗi nút diễn tả kiểm tra cho số thuộc tính trường hợp nhánh xuống từ nút đại diện cho giá trị cho thuộc tính Một trường hợp phân loại việc bắt đầu nút gốc , kiểm tra thuộc tính xát định nút sau chuyển xuống nhánh tương ứng với việc đánh giá thuộc tính Q trình lặp lại cho lúc nút gốc xát định 1.4 Giải thuật học định: Cây định phương pháp xấp xỉ hóa hàm mục tiêu giá trị rời ,rạc hàm học thể định Học định phương pháp thực dụng sử dụng rộng rãi cho phương pháp suy diễn qui nạp Giải thuật học định sử dụng thành công hệ chuyên gia việc nằm bắt kiến thức.Cơng việc sử dụng hệ thống việc sử dụng phương pháp qui nạp cho giá trị cho trước thuộc tính đối tượng chưa biết để xát định phân loại xấp xỉ theo luật định.Cây định phân loại trường hợp cách duyệt từ nút gốc đến nút lá.Chúng ta nút gốc định , kiểm tra thuộc tính xát định nút sau chuyển xuống nhánh theo giá trị thuộc tính tập hợp cho trước.Q trình lặp lại Giải thuật định thích hợp cho điều đây: 1.Mỗi trường hợp biểu diễn cặp giá trị thuộc tính.Ví dụ thuộc tính “nhiệt độ“ có giá trị “nóng”,”mát”, “lạnh”.Chúng đồng thời liên quan đến thuộc tính mở rộng , giá trị tiếp theo, liệu tính tốn ( giá trị thuộc tính số) dự án 2.Hàm mục tiêu có giá trị đầu giá trị rời rạc.Nó dễ dàng liên hệ đến trường hợp mà gán vào định sai.Nó mở rộng hàm mục tiêu đến giá trị đầu giá trị thực 3.Những liệu đưa vào chứa đựng nhiều lỗi điều liên quan đến kĩ thuật giản lược liệu thừa 1.5 Tại Học định phương pháp học qui nạp hấp dẫn: Những phương pháp học qui nạp tạo thành công thức cho không gian giả thuyết tổng qt việc tìm tính qui tắc kinh nghiệm dựa liệu ví dụ Với học qui nạp , học định hấp dẫn nguyên nhân: Cây định tổng quát tốt cho trường hợp ta không để ý đến , trường hợp mô tả giới hạn đặc tính mà liên quan đến khái niệm mục tiêu Những phương pháp hiệu tính tốn số hạng tỉ lệ thức đến số trường hợp liệu đưa vào tính tốn Kết định đưa biểu diễn ý niệm mà dễ dàng cho người đưa q trình phân loại hiển nhiên 2.Giải thuật học định – ID3 Cơ bản: 2.1.ID3 Cơ bản: ID3 giải thuật học định phát triển Ross Quinlan (1983) Ý tưởng giải thuật ID3 để xây dựng định việc sử dụng cách tìm kiếm từ xuống tập hợp cho trước để kiểm tra thuộc tính nút Để chọn thuộc tính mà hữu ích cho phân loại tập hợp cho trước , đưa metric thu thập thơng tin Để tìm cách tối ưu để phân loại tập hợp thông tin , vấn đề đặt cần phải làm tối thiểu hóa ( Chẳng hạn, tối thiểu chiều cao cây) Như cần số chức mà đánh giá trường hợp nào cho phân chia cân nhất.Matric thu thập thông tin hàm 2.2 Entropy-Đồng định lượng tập hợp thơng tin: Để định nghĩa thơng tin tìm cách xát cần phải tìm hiểu hàm entropy trước tiên Đầu tiên khơng tính tổng quát giả sử kết việc phân loại trường hợp định thuộc vào hai loại gọi chúng P ( dương ) N (âm) Cho trước tập hợp S , bao hàm mục tiêu dương âm, hàm entropy S liên quan đến phân loại : Entropy(S) = -P(positive)log P(positive) – P(negative)log P(negative) P(positive) : tỉ lệ thức trường hợp dương S P(negative): tỉ lệ thức trường hợp âm S Cho ví dụ , S (0.5+,0.5-) then Entropy(S) 1, S (0.67+,0.33-) Entropy(S) Để ý khả phân bố nhiều dạng khác thơng tin lớn Chúng ta để ý hàm entropy định lượng cho tính khơng khiết tập hợp thơng tin đưa vào.Nhưng làm liên quan đến tối ưu hoá việc tạo định tạo vịêc phân loại trường trường hợp Những thấy sau câu trả lời cho vấn đề 2.3 Thu thập thông tin - định lượng thu giảm mong đợi hàm Entropy: Như đề cập trước đây, để tối thiểu hóa chiều sâu định , duyệt nhánh cây, cần chọn thuộc tính tối ưu để chia nút cây, mà dễ dàng cho thuộc tính với thu giảm entropy lựa chọn tốt Chúng ta định nghĩa thu thập thông tin việc thu giảm mong đợi entropy liên quan đến thuộc tính xát định phân chia node thuộc định Gain(S,A)=Entropy(S) - Sum for v from to n of (|Sv|/|S|) * Entropy(Sv) Chúng ta sử dụng khái niệm thu thập để đánh giá tầm quan trọng thuộc tính xây dựng định mà nút chứa thuộc tính mà nhận lớn thuộc tính chưa xem xét đường từ gốc Mục đích việc thứ tự : Để tạo định nhỏ mà record xát định sau vài lần định phân chia Để kết nối hi vọng việc tối thiểu trình tạo định Giải thuật ID3: 3.1 Hiện thực giải thuật ID3: Nội dung giải thuật: ID3 ( Learning Sets S, Attributes Sets A, Attributesvalues V) Return Decision Tree Begin Load learning sets first, create decision tree root node 'rootNode', add learning set S into root node as its subset For rootNode, we compute Entropy(rootNode.subset) first If Entropy(rootNode.subset)==0, then rootNode.subset consists of records all with the same value for the categorical attribute, return a leaf node with decision attribute:attribute value; If Entropy(rootNode.subset)!=0, then compute information gain for each attribute left(have not been used in splitting), find attribute A with Maximum(Gain(S,A)) Create child nodes of this rootNode and add to rootNode in the decision tree For each child of the rootNode, apply ID3(S,A,V) recursively until reach node that has entropy=0 or reach leaf node End ID3 3.2 Ví dụ : Để mô tả hoạt động ID3 sử dụng ví dụ “Play Tennis”.Sự mơ tả tượng trưng thuộc tính sau: Attribute Possible Values: Outlook sunny, overcast , rain Temperature hot , mild, cood Humidity high,normal Windy true,false Decision n(negative),p(positive) Tập Leaning set cho ví dụ chơi tennis: Outlook Temperature Humidity Windy Decision sunny hot high false n sunny hot high true n overcast hot high false p rain mild high false p rain cool normal false p rain cool normal false n overcast cool normal true p sunny mild high false p sunny rain sunny overcast overcast rain mild mild mild mild hot mild normal normal normal high normal high true false true true false true p p p p p n Giải thuật ID3 thực sau: Tạo nút gốc( rootNode) , chứa đựng toàn learning set tập hợp chúng (subset) sau tính : Entropy(rootNode.subset)= -(9/14)log ( 9/14 ) – ( 5/14)log (5/14)= 0.940 Tính tốn thơng tin nhận cho thuộc tính : Gain(S,Windy)= Entropy(S)-(8/14)Entropy(S false) – (6/14)Entropy(S true) = 0.048 Gain(S,Humidity) = 0.151 Gain(S,Temperature) = 0.029 Gain(S,Outlook) = 0.246 Chọn lựa thuộc tính với thơng tin nhận tối đa , phân chia theo thuộc tính “outlook” Áp dụng ID3 cho nút nút gốc , đạt đến nút nút có entropy = 3.3 Sự liên quan đến thuộc tính mang giá trị liên tục : Sự định nghĩa ban đầu ID3 bị giới hạn việc liên quan đến tập giá trị rời rạc Chúng nắm giữ cách hiệu thuộc tính tượng trưng Tuy nhiên , mở rộng phạm vi hoạt động cho thuộc tính có giá trị liên tục ( giá trị số) để phù hợp với giới thực Những phải làm định nghĩa giá trị rời rạc để phân giá trị liên tục thành thuộc tính tượng trưng lần Outlook sunny sunny overcast rain rain rain overcast sunny sunny rain sunny Temperature hot hot hot mild cool cool cool mild cool mild mild Humidity 0.9 0.87 0.93 0.89 0.80 0.59 0.77 0.91 0.68 0.84 0.72 Windy false true false false false true true false false false true Decision n n p p p n p n p p p overcast overcast rain mild hot mild 0.49 0.74 0.86 true false true p p n thuộc tính humidity, cần phải tạo giá trị logic true humidity < =c false trường hợp khác Điều lại tính ngưỡng tối ưu c Trong ví dụ , thông tin nhiều nhận thuộc tính “outlook”.Trong gốc tập “outlook:sunny”, tính thu thập thơng tin cho “Humidity” thuộc tính Để làm xếp humidity đây: Humidity 0.68 0.72 0.87 0.9 0.91 Playtennis p p n n n Chúng chọn ngưỡng mà tạo thu thập thông tin lớn Bằng việc xếp giá trị số sau xát định ví dụ xát với mà khác với phân chia mục tiêu.Chúng ta tạo tập hợp ngưỡng cho phép sau tính thơng tin đạt với ngưỡng tối ưu cho việc phân chia Ngưỡng phép trường hợp 1: Humidity > (0.7+0.87)/2 hay Humidity > 0.795 với thập thông tin G(S,Humidity) =0.97 Nếu có ứng cử cần tìm thu thập thông tin nhiều 3.4 Mở rộng ID3 với liệu tính tốn thực : Như đề cập trước đây, ID3 hoàn toàn hiệu việc liên hệ đến hàm mục tiêu giá trị tính rời rạc.Nó dễ dàng liên hệ đến trường hợp mà gán giá trị định logic , “true “ “false”,”p (positive)” and “n(negative)” Điều mở rộng hàm mục tiêu sang giá trị output thực 4.Những thiếu sót giải thuật ID3: 4.1 Trường hợp thứ : Một thiếu sót quan trọng ID3 khơng gian phân chia hợp lệ node cạn kiệt Một phân chia phân hoạch trường hợp không gian mà kết đạt từ việc thử nghiệm node định ID3 cháu cho phép kiểm tra tại thuộc tính đơn nhánh kết cho từ kiểm tra 4.2 Trường hợp thứ 2: Một thiếu sót mà ID3 mắc phải dựa vào nhiều vào số lượng tập hợp liệu đưa vào Quản lý tạp nhiễu tập liệu vào vô quan trọng ứng dụng giải thuật học định vào giới thực Cho ví dụ ,Khi có lẫn tạp tập liệu đưa vào số lượng ví dụ đưa vào nhỏ để tạo ví dụ điển hình hàm mục tiêu đúng.ID3 dẫn đến việc tạo định sai Có nhiều mở rộng từ giải thuật ID3 phát triển để áp dụng luật học định vào giới thực , post-pruning tree , quản lý thuộc tính giá trị thực , liên quan đến việc thiếu thuộc tính , sử dụng tiêu chuẩn chọn lựa thuộc tính khác thu thập thông tin 5.Giải thuật mở rộng C4.5: C4.5 mở rộng giải thuật ID3 số khía cạnh sau: Trong việc xây dựng định , chúng liên hệ với tranning set mà có records với giá trị thuộc tính đến việc đánh giá việc thu thập thông tin tỉ số thu thập thông tin , cho thuộc tính việc xem xét record mà thuộc tính định nghĩa Trong việc sử dụng định , phân loại record mà có giá trị thuộc tính khơng biết việc ước lượng kết có khả sãy ra.Trong ví dụ chơi đánh gôn , đưa record mà outlook sunny humidity chưa cho biết , xử lý sau: Chúng ta di chuyển từ nút gốc Outlook đến nút Humidity theo cung đánh nhãn sunny Ở điểm từ lúc khơng biết giá trị Humidity để ý humidity 75 có records , humidity lớn 75 có records có record khơng hoạt động Như điều đưa câu trả lới cho record khả (0.4,06) cho chơi gôn không chơi gơn Chúng ta liên hệ đến giá trị liên tục Giả sử thuộc tính Ci có tầm giá trị thuộc tính liên tục Chúng ta xem xét giá trị tập learning set Cho chúng xắp sếp thứ tự tăng dần A1, A2, ,Am sau với giá trị Ai i=1,2, ,m.Chúng ta chia records thành có giá trị từ Ci trở lên bao gồm Aj có giá trị lớn Aj Với lần phân hoạch tính lại giá trị thu thập tỉ số thu thập chọn phân hoạch có tỉ số thu thập thông tin nhận tối đa Trong ví dụ chơi Golf , humidity T training set xát định thơng tin cho lần phân chia tìm phân chia tốt 75 Phạm vi thuộc tính trở thành {75} Chú ý phương pháp liên quan đến số quan trọng việc tính tốn Cây định thu giảm tập luật suy dẫn : Việc xây dựng định nhờ vào training set cách chúng xây dựng liên quan nghiêm ngặt đến hầu hết record training set Trong thực tế , để làm điều hồn tồn phức tạp Với đường dài khơng Việc thu giảm định thực việc thay thành nút lá.Sự thay thực nơi mà luật định thiết lập tần suất lỗi gây lớn nút lá.Cho ví dụ với đơn giản sau: Color red Success blue Failure chứa records thứ training red success thứ hai trainning blue failures sau Test Set tìm thấy red failures blue success , xem xét việc thay việc thay node đơn Failure Sau việc thay cịn lại lỗi thay lỗi Winston làm để sử dụng Fisher's exact test để xát định thuộc tính phân loại thực phụ thuộc vào thuộc tính khơng xát định Nếu điều khơng sãy thuộc tính khơng xát định khơng cần phải xuất đường định Quinlan Breiman đề nghị heuristic phức tạp cho việc thu giảm định Một điều dễ dàng làm dẫn luật từ định : viết luật từ đường định từ gốc đến lá.Vế trái luật xây dựng dễ dàng từ nhãn nút nhãn cung Những luật rút rút gọn sau: Gọi LHS LHS luật Cho LHS’ nhận cách thu giảm số điều kiện LHS Chúng ta chắn thay LHS LHS’ luật tập training set thỏa mãn LHS LHS’ tương đương Một luật thu giảm cách sử dụng metacondition ví dụ “ khơng có luật khác áp dụng ” Giải thuật mở rộng See5/C5.0 : “See5 dạng nghệ thuật hệ thống xây dựng phân loại dạng thức định tập luật “ See5 thiết kế hoạt động sở liệu lớn kết hợp đổi boosting Kết tạo See5 C5.0 tương tự Hoạt động trước Windows95/98/NT C5.0 phần hoạt động Unix See C5.0 công cụ khai khái liệu phức tạp cho mẫu khai phá liệu mà phát họa loại tập hợp chúng thành đối tượng phân loại sử dụng chúng để tiên đốn Đặc điểm C5.0 :  C5.0 thiết kế để phân tích sở lịêu quan trọng chứa đựng hàng ngàn đến hàng trăm ngàn records.và hàng chục đến hàng trăm số liệu tên field  Để tối đa khả giải thích , đối tượng phân loại See5.0 /C5.0 diễn tả định tập luật if – then.Dạng thức dễ hiểu so với neutron network  C5.0 dễ dàng sử dụng khơng gọi kiến thức cao cấp thống kê học máy Giải thuật See5/C5.0 tốt C4.5: C5.0 hệ thống Unix See5 Windows phiên cao cấp C4.5 nhiều khía cạnh quan trọng Chúng ta thử so sánh C5.0 C4.5 hệ thống Unix 1.Về tập luật (Ruleset):nhanh nhiều tốn nhớ hơn: Cả C5.0 C4.5 cung cấp lựa chọn cho dạng thức phân loại – định tập luật (ruleset) Trong nhiều ứng dụng tập luật (ruleset) ưu tiên sử dụng chúng đơn giản dễ hiểu định Nhưng phương pháp để tìm luật C4.5 chậm chiếm nhiều nhớ.C5.0 thể hoàn thiện vấn đề tạo tập luật cải tiến gây ấn tượng mạnh mẽ 2.Cây định : nhanh nhỏ : Với tập liệu (dataset) C4.5 C5.0 sản sinh luật với xát dự đốn nhau.Sự khác yếu kích cở thời gian tính tốn.Cây C5.0 nhỏ nhanh số yếu tố 3.Sự nâng lên(Boosting): Dựa nguyên cứu Freund Schapire , phát triển đầy hấp dẫn mà khơng có tương tự C4.5.Boosting kỹ thuật để tạo kết hợp nhiều đối tượng phân loại để cải thiện tính xát tiên đoán C5.0 hỗ trợ Booting với số liệu số thử nghiệm Thông thường , C5.0 thời gian lâu để tạo đối tượng phân loại (classifier) Nhưng kết phân tích định lượng tính tốn cơng thêm Boosting cố gắng để đạt đỉnh cao xát tiên đốn u cầu phải đạt tới Đặc biệt đối tượng phân loại khơng nâng lên hồn tồn xát 4.Những chức mới: C5.0 kết hợp nhiều chức variable misclassfication costs.Trong C4.5 tất lỗi xem nhau.Nhưng ứng dụng thực tế có số lỗi q trình phân loại nguy hiểm khác C5.0 chấp nhận chi phí phân chia cặp lớp tiên đoán.Nếu quan điểm áp dụng , C5.0 sau xây dựng đối tượng phân loại để tối thiểu hóa giá trị phân loại sai mong đợi tần suất lỗi C5.0 có nhiều kiểu liệu có C4.5 bao gồm ngày , thuộc tính giá trị rời rạc xếp thứ tự case labels Thêm vào giá trị thiếu (missing value).C5.0 cho phép giá trị coi không áp dụng Hơn , C5.0 cung cấp điều kiện dễ dàng để định nghĩa thuộc tính hàm thuộc tính khác Những ứng dụng khai phá liệu gần hình thức hố với kích thước lớn , với hàng trăm chí hàng ngàn thuộc tính C5.0 tự động lọc thuộc tính , loại bỏ xuất bên lề trước lớp phân loại xây dựng Đối với ứng dụng loại , phân loại dẫn đến đối tượng nhỏ tiên đốn xát chí thu giảm thời gian tạo tập luật C5.0 dễ dàng sử dụng Những chọn lựa đơn giản hóa mở rộng.- để hỗ trợ lấy mẫu cross-validation , lúc chương trình C4.5 để tạo định tập luật kết hợp vào chương trình Phiên windows See5 xây dựng giao diện đồ họa thân thiện thêm vào số chức hỗ trợ khác.Ví dụ Cross-Reference Window làm cho đối tượng phân loại dễ hiểu việc liên kết trường hợp đến phần liên quan đến việc phân loại Khơng gian giả thuyết tìm kiếm định: Cũng với phương pháp học qui nạp khác,ID3 mơ tả việc tìm kiếm khơng gian giả thuyết để tìm giả thuyết mà phù hợp với training example.Khơng gian giả thuyết tìm kiếm ID3 tập hợp định có thể.ID3 thực tìm kiếm theo cách leo núi không gian giả thuyết từ đơn giản đến phức tạp.Nó rỗng sau theo tiến trình quan sát giả thuyết tỉ mỉ tìm kiếm định mà phân loại cách xát training data.Chức phân loại mà dẫn đường cho việc tìm kiếm theo cách thức leo núi (hill-climbing) định lượng thơng tin nhận ( the information gain measure) Bằng quan sát ID3 ngữ cảnh khơng gian tìm kiếm chiến thuật tìm kiếm.Chúng ta thấy số khả giới hạn  Khơng giả thuyết ID3 tất định không gian đầy đủ hàm giá trị rời rạc , liên quan đến thuộc tính cho phép.Bởi hàm giá trị rời rạc giới hạn thể số định , ID3 tránh rủi ro tìm kiếm khơng gian giả thuyết khơng đầy đủ ( ví dụ phương pháp mà quan tâm đến giả thuyết kết hợp).Đây khơng gian giả thuyết khơng chứa hàm mục tiêu (target function)  ID3 trì giả thuyết đơn lẻ tìm kiếm thơng qua khơng gian định Bằng việc xát định giả thuyết đơn lẻ , ID3 khả mà theo thể tất giả thuyết phù hợp cách rõ ràng theo sau.Ví dụ, khơng có khả xát định làm định phù hợp với private bool allSamplesNegatives(DataTable samples, string targetAttribute) { foreach (DataRow row in samples.Rows) { if ( (bool)row[targetAttribute] == true) return false; } return true; } private ArrayList getDistinctValues(DataTable samples, string targetAttribute) { ArrayList distinctValues = new ArrayList(samples.Rows.Count); foreach(DataRow row in samples.Rows) { if (distinctValues.IndexOf(row[targetAttribute]) == -1) distinctValues.Add(row[targetAttribute]); } return distinctValues; } private object getMostCommonValue(DataTable samples, string targetAttribute) { ArrayList distinctValues = getDistinctValues(samples, targetAttribute); int[] count = new int[distinctValues.Count]; foreach(DataRow row in samples.Rows) { int index = distinctValues.IndexOf(row[targetAttribute]); count[index]++; } int MaxIndex = 0; int MaxCount = 0; for (int i = 0; i < count.Length; i++) { if (count[i] > MaxCount) { MaxCount = count[i]; MaxIndex = i; } } return distinctValues[MaxIndex]; } private TreeNode internalMountTree(DataTable samples, string targetAttribute, Attribute[] attributes) { if (allSamplesPositives(samples, targetAttribute) == true) return new TreeNode(new Attribute(true)); if (allSamplesNegatives(samples, targetAttribute) == true) return new TreeNode(new Attribute(false)); if (attributes.Length == 0) return new TreeNode(new Attribute(getMostCommonValue(samples, targetAttribute))); mTotal = samples.Rows.Count; mTargetAttribute = targetAttribute; mTotalPositives = countTotalPositives(samples); mEntropySet = calcEntropy(mTotalPositives, mTotal mTotalPositives); Attribute bestAttribute = getBestAttribute(samples, attributes); TreeNode root = new TreeNode(bestAttribute); DataTable aSample = samples.Clone(); foreach(string value in bestAttribute.values) { aSample.Rows.Clear(); DataRow[] rows = samples.Select(bestAttribute.AttributeName + " = " + "'" + value + "'"); foreach(DataRow row in rows) { aSample.Rows.Add(row.ItemArray); } ArrayList aAttributes = new ArrayList(attributes.Length - 1); for(int i = 0; i < attributes.Length; i++) { if (attributes[i].AttributeName != bestAttribute.AttributeName) aAttributes.Add(attributes[i]); } if (aSample.Rows.Count == 0) { return new TreeNode(new Attribute(getMostCommonValue(aSample, targetAttribute))); } else { DecisionTreeID3 dc3 = new DecisionTreeID3(); TreeNode ChildNode = dc3.mountTree(aSample, targetAttribute, (Attribute[])aAttributes.ToArray(typeof(Attribute))); root.AddTreeNode(ChildNode, value); } } return root; } public TreeNode mountTree(DataTable samples, string targetAttribute, Attribute[] attributes) { mSamples = samples; return internalMountTree(mSamples, targetAttribute, attributes); } } class ID3Sample { public static void printNode(TreeNode root, string tabs) { Consunnye.WriteLine(tabs + '|' + root.attribute + '|'); if (root.attribute.values != null) { for (int i = 0; i < root.attribute.values.Length; i++) { Consunnye.WriteLine(tabs + "\t" + ""); TreeNode childNode = root.getChildByBranchName(root.attribute.values[i]); printNode(childNode, "\t" + tabs); } } } static DataTable getDataTable() { DataTable result = new DataTable("samples"); DataColumn column = result.Columns.Add("outlook"); column.DataType = typeof(string); column = result.Columns.Add("temperature"); column.DataType = typeof(string); column = result.Columns.Add("humidity"); column.DataType = typeof(string); column = result.Columns.Add("wind"); column.DataType = typeof(string); column = result.Columns.Add("result"); column.DataType = typeof(bool); result.Rows.Add(new object[] {"sunny", "hot", "high", "weak", false}); //D1 result.Rows.Add(new object[] {"sunny", "hot", "high", "strong", false}); //D2 result.Rows.Add(new object[] {"overcast", "hot", "high", "weak", true}); //D3 result.Rows.Add(new object[] {"rain", "mild", "high", "weak", true}); //D4 result.Rows.Add(new object[] {"rain", "cool", "normal", "weak", true}); //D5 result.Rows.Add(new object[] {"rain", "cool", "normal", "weak", false}); //D6 result.Rows.Add(new object[] {"overcast", "cool", "normal", "weak", true}); //D7 result.Rows.Add(new object[] {"sunny", "mild", "high", "weak", false}); //D8 result.Rows.Add(new object[] {"sunny", "cool", "normal", "weak", true}); //D9 result.Rows.Add(new object[] {"rain", "mild", "normal", "weak", true}); //D10 result.Rows.Add(new object[] {"sunny", "mild", "normal", "weak", true}); //D11 result.Rows.Add(new object[] {"overcast", "mild", "high", "weak", true}); //D12 result.Rows.Add(new object[] {"overcast", "high", "normal", "weak", true}); //D13 result.Rows.Add(new object[] {"rain", "mild", "high", "weak", false}); //D14 return result; } /// /// The main entry point for the application /// /// [STAThread] static void Main(string[] args) { Attribute outlook = new Attribute("outlook", new string[] {"sunny", "overcast", "rain"}); Attribute temperature = new Attribute("temperature", new string[] {"high", "cool", "mild"}); Attribute humidity = new Attribute("humidity", new string[] {"high", "normal"}); Attribute wind = new Attribute("wind", new string[] {"weak", "weak"}); Attribute[] attributes = new Attribute[] {outlook, temperature, humidity, wind}; DataTable samples = getDataTable(); DecisionTreeID3 id3 = new DecisionTreeID3(); TreeNode root = id3.mountTree(samples, "result", attributes); printNode(root, ""); } } } Source code thực ID3 ví dụ “lays eggs” ngôn ngữ Java class Node { public int index; public double threshold; public Node onNode; public Node offNode; public Node parentNode; public Node() { parentNode = null; onNode = null; offNode = null; index = -1; } public Node(Node parent) { parentNode = parent; onNode = null; offNode = null; index = -1; } } class Vector { private int nelem; private double[] data; public Vector() { nelem = -1; data = null; } public Vector(int elem) { nelem = elem; data = new double[elem]; } public double getCell(int n) { return data[n]; } public void setCell(int n, double value) { data[n] = value; } public void setSize(int elem) { nelem = elem; data = new double[elem]; } public int getSize() { return nelem; } } class Matrix { private int ncols, nrows; private Vector[] data; public Matrix() { ncols = -1; nrows = -1; data = null; } public Matrix(int rows, int cols) { setSize(rows, cols); } public void setSize(int rows, int cols) { int i; ncols = cols; nrows = rows; data = new Vector[rows]; for (i = 0; i < rows; i++) data[i] = new Vector(cols); } public void setCell(int row, int column, double value) { data[row].setCell(column, value); } public double getCell(int row, int column) { return data[row].getCell(column); } public int getX() { return ncols; } public int getY() { return nrows; } } class ID3 { public final static double LN2 = 0.69314718055994531; public final static int STATE_ON = 1; public final static int STATE_OFF = -1; public final static int STATE_INACTIVE = 0; private static int retState = STATE_INACTIVE; public static double entropy(double x) { if (x > 0) return x * Math.log(x) / LN2; else return 0.0; } private static double negEntropy(Matrix m, Node current, int target) { boolean match; int r, nOn=0, nOff=0, p1=0, p2=0; double negEntropyOn, negEntropyOff, pOn, pOff; Node parent, node; /* scan through all data samples, counting the number of samples which exceed the threshold */ for (r = 0; r < m.getY(); r++) { match = true; // tells us whether this data sample should be handled at this node node = current; while (node.parentNode != null) { // until at root (where all match) parent = node.parentNode; if (node == parent.onNode) { if (m.getCell(r,parent.index) < parent.threshold) match = false; // in the parent's ON-node but classified as OFF, i.e don't handle at this node } else { if (node == parent.offNode) { if (m.getCell(r,parent.index) >= parent.threshold) match = false; // in the parent's OFF-node but classified as ON, i.e don't handle at this node } } node = parent; } if (match) { if (m.getCell(r,current.index) >= current.threshold) { nOn++; if (m.getCell(r,target) >= 0.5) p1++; } else { nOff++; if (m.getCell(r,target) >= 0.5) p2++; } } } /* nOn now contains the number of samples which exceeded the threshold, nOff now contains the number of samples which were lower than the threshold, p1 now contains the number of samples which exceeded the threshold and which should be "Yes", p2 now contains the number of samples which were lower than the threshold and which should be "Yes" */ if (nOn > 0) { // calculate NE_on - here called negEntropyOn pOn = (double)p1/(double)nOn; pOff = 1.0 - pOn; negEntropyOn = -entropy(pOn)-entropy(pOff); } else negEntropyOn = 0.0; if (nOff > 0) { // calculate NE_off - here called negEntropyOff pOn = (double)p2/(double)nOff; pOff = 1.0 - pOn; negEntropyOff = -entropy(pOn)-entropy(pOff); } else negEntropyOff = 0.0; /* given the threshold, we now determine if the data samples which exceed this threshold should be classified as all being ON or OFF, or if further splitting is needed */ if ((p1 == nOn) && (p2 == nOff)) // if ALL data samples in this node which exceed the threshold also are "Yes" then set state to ON retState = STATE_ON; else if ((p1 == 0) && (p2 == 0)) // if NO data samples in this node which exceed the threshold are "Yes" then set state to OFF retState = STATE_OFF; else // else we will have to split this into a subtree retState = STATE_INACTIVE; return (negEntropyOn*(double)nOn+negEntropyOff*nOff)/(double) (nOn+nOff); } private static Node buildDecision(Matrix m, Node parent, int target, int state) { int a, r, bestAttr = -1; double negEntropyValue, bestThreshold = -1.0; double minNegEntropyValue = 1.0; Node thisNode = new Node(parent); if (parent != null) { if (state == STATE_ON) parent.onNode = thisNode; else { if (state == STATE_OFF) parent.offNode = thisNode; } } /* calculate negentropy for every attribute-value in the dataset and pick the best one, i.e the lowest */ for (a = 0; a < m.getX(); a++) { // pick one attribute (column) for (r = 0; r < m.getY(); r++) { // then use a data sample to set threshold (row) if (a != target) { // don't use the target attribute as input :) thisNode.index = a; thisNode.threshold = m.getCell(r,a); negEntropyValue = negEntropy(m, thisNode, target); if (negEntropyValue < minNegEntropyValue) { } minNegEntropyValue = negEntropyValue; bestAttr = a; bestThreshold=m.getCell(r,a); } } } thisNode.index = bestAttr; thisNode.threshold = bestThreshold; if (retState != STATE_INACTIVE) { // node classifies all data samples as either ON or OFF thisNode.onNode = null; thisNode.offNode = null; thisNode.index = retState; } else { // we split the node into a (sub-)tree thisNode.onNode = buildDecision(m, thisNode, target, STATE_ON); thisNode.offNode = buildDecision(m, thisNode, target, STATE_OFF); } } return thisNode; public static void printTree(Node node) { if (node.onNode == null) { if (node.index == STATE_ON) System.out.print("ON"); else System.out.print("OFF"); return; } else System.out.print("if ( ATT" + node.index + ">=" + node.threshold + " then "); printTree(node.onNode); System.out.print(" else "); printTree(node.offNode); System.out.print(" ) "); } public static void main(String[] args) { Node root = new Node(); Matrix m = new Matrix(6,5); m.setCell(0,0,1); m.setCell(0,1,1); m.setCell(0,3,0); m.setCell(0,4,1); m.setCell(1,0,0); m.setCell(1,1,0); m.setCell(1,3,1); m.setCell(1,4,1); m.setCell(2,0,1); m.setCell(2,1,1); m.setCell(2,3,0); m.setCell(2,4,1); m.setCell(3,0,1); m.setCell(3,1,1); m.setCell(3,3,0); m.setCell(3,4,1); m.setCell(4,0,1); m.setCell(4,1,0); m.setCell(4,3,1); m.setCell(4,4,0); m.setCell(5,0,1); m.setCell(5,1,0); m.setCell(5,3,0); m.setCell(5,4,0); m.setCell(0,2,0); m.setCell(1,2,0); m.setCell(2,2,0); m.setCell(3,2,0); m.setCell(4,2,0); m.setCell(5,2,1); /* use attribute index as target for the decision tree */ root = buildDecision(m, root, 4, STATE_INACTIVE); printTree(root); System.out.println(); } } Source code thực ID3 ví dụ “lays eggs” ngơn ngữ C++ (bao gồm file id3.h id3.cpp): file id3.h: #define #define #define #define #define LN2 0.69314718055994531 ENTROPY(x) ((x)>0?(x)*log(x)/LN2:0.0) STATE_ON STATE_OFF -1 STATE_INACTIVE class Node { public: Node() { parentNode=onNode=offNode=0; index=-1; } Node(Node *parent) { parentNode=parent; onNode=offNode=0; index=-1; } int index; double threshold; Node *onNode; Node *offNode; Node *parentNode; }; class Vector { public: Vector() { nelem=-1; data=0; } Vector(int elem) { nelem=elem; data=new double[elem]; } double& operator[] (int n) { return data[n]; } void setSize(int elem) {nelem=elem; data=new double[elem]; } int getSize() { return nelem; } private: int nelem; double *data; }; class Matrix { public: Matrix() { ncols=nrows=-1; Matrix(int rows, int cols) int i; ncols=cols; nrows=rows; data=new Vector[rows]; for (i=0; ionNode) { if (m[r][parent->index]threshold) match=0; // in the parent's ON-node but classified as OFF, i.e don't handle at this node } else { if (node==parent->offNode) { if (m[r][parent->index]>=parent->threshold) match=0; // in the parent's OFF-node but classified as ON, i.e don't handle at this node } } node=parent; } } if (match) { if (m[r][current->index]>=current->threshold) { nOn++; if (m[r][target]>=0.5) p1++; } else { nOff++; if (m[r][target]>=0.5) p2++; } } /* nOn now contains the number of samples which exceeded the threshold, nOff now contains the number of samples which were lower than the threshold, p1 now contains the number of samples which exceeded the threshold and which should be "Yes", p2 now contains the number of samples which were lower than the threshold and which should be "Yes" */ if (nOn>0) { // calculate NE_on - here called negEntropyOn pOn=(double)p1/(double)nOn; pOff=1.0-pOn; negEntropyOn=-ENTROPY(pOn)-ENTROPY(pOff); } else negEntropyOn=0.0; if (nOff>0) { // calculate NE_off - here called negEntropyOff pOn=(double)p2/(double)nOff; pOff=1.0-pOn; negEntropyOff=-ENTROPY(pOn)-ENTROPY(pOff); } else negEntropyOff=0.0; /* given the threshold, we now determine if the data samples which exceed this threshold should be classified as all being ON or OFF, or if further splitting is needed */ if ((p1==nOn) && (p2==nOff)) // if ALL data samples in this node which exceed the threshold also are "Yes" then set state to ON *retState=STATE_ON; else if ((p1==0) && (p2==0)) // if NO data samples in this node which exceed the threshold are "Yes" then set state to OFF *retState=STATE_OFF; else // else we will have to split this into a subtree *retState=STATE_INACTIVE; return (negEntropyOn*(double)nOn+negEntropyOff*nOff)/(double) (nOn+nOff); } Node *buildDecision(Matrix m, Node *parent, int target, int state) { int a, r, bestAttr=-1, retState; double negEntropyValue, bestThreshold=-1.0; Node *thisNode=new Node(parent); double minNegEntropyValue=1.0; if (parent) { if (state==STATE_ON) parent->onNode=thisNode; else { if (state==STATE_OFF) parent->offNode=thisNode; } } /* calculate negentropy for every attribute-value in the dataset and pick the best one, i.e the lowest */ for (a=0; a