Data Mining: Opdracht 2 7 juli 2006
Egbert Kroese
(#0134252)
Paul Lammertsma
(#0305235)
Inhoudsopgave 1.
De datasets ..................................................................................................3 1.1 Iris ........................................................................................................3 1.2 Vote ......................................................................................................3 1.3 Autos ....................................................................................................4
2.
De algoritmen .............................................................................................4 2.1 Naive Bayes .........................................................................................4 2.2 C4.5 ......................................................................................................5 2.3 Ripper...................................................................................................5 2.4 Support Vector Machine ......................................................................6 2.5 Boosting ...............................................................................................6 2.5.1 Adaboost met C4.5.......................................................................7 2.5.2 Adaboost met Decision Stumps ...................................................7 2.6 Intermezzo: Bagging ............................................................................8
3.
Conclusies ...................................................................................................8 3.1 Conclusie Naive Bayes ........................................................................8 3.2 Conclusies C4.5 en Adaboost met C4.5...............................................8 3.3 Conclusie Ripper..................................................................................9 3.4 Conclusie Support Vector Machine .....................................................9 3.5 Conclusie Adaboost met Decision Stumps ........................................10 3.6 Conclusies Algemeen.........................................................................10
4.
Appendix ...................................................................................................12
5.
Referenties ................................................................................................16
1.
De datasets
De drie opgegeven datasets, iris, vote en autos, hebben zowel met betrekking tot hun instanties als hun attributen opvallende verschillen. Een analyse is gedaan naar de drie meegeleverde datasets en is uitgezet in Tabel 1. Bij deze analyse gaat voornamelijk om het aantal klasses, de attribuuttypes en het aantal attributen met ontbrekende waardes. De verschillende algoritmes waar straks naar gekeken zal worden gaan immers anders om met deze eigenschappen, en kunnen daarom de classificatie beïnvloeden. Naam
Instanties Classes
Iris Vote Autos
150 435 205
3 2 7
Attribuuttypes Num. Nom. Int. 4 – – – 17 – 15 10 1
# attributen met missende waardes 0 15 7
Tabel 1
1.1
Iris
De dataset iris heeft twee karakteristieke eigenschappen. Ten eerste valt het op dat deze dataset uitsluitend numerieke waarden bevat. Gezien het feit dat verschillende algoritmen anders omgaan met numerieke of nominale waarden, zal deze eigenschap ongetwijfeld invloed hebben op de classificatie en uiteindelijk het meest geschikte algoritme. Ten tweede maakt deze dataset het de meeste algoritmen wat makkelijker omdat er geen attributen zijn met ontbrekende waarden. Wij hoeven dus hier geen rekening mee te houden.
1.2
Vote
Ook deze dataset is kenmerkend doordat alle attributen van dezelfde soort zijn. Het gaat deze keer niet om numerieke waarden, maar juist allemaal om nominale. Willen wij het beste algoritme vinden, zullen we een algoritme moeten zoeken dat hierop toegespitst is. Ook interessant is dat vote geheel binair is: alle attributen – en met name de uitkomst – kunnen precies twee waarden aannemen.
1.3
Autos
Tijdens het eerste practicum hebben we deze dataset onderzocht, en ontdekt dat deze zowel numeriek, nominaal als integerwaarden bevat. De attributen zijn afwisselend sterk samenhangend of geheel onsamenhangend, en er lijkt veel sprake van noise te zijn. Mogelijk zullen sommige algoritmes moeite hebben met classificatie doordat instanties uiteindelijk zeven verschillende waarden aan kunnen nemen, en dat er in sommige gevallen attribuutwaarden ontbreken.
2.
De algoritmen
Wij hebben circa vijftig experimenten uitgevoerd op de datasets met vijf verschillende algoritmes: Naive Bayes, C4.5, Ripper en Adaboost met C4.5 en Decision Stumps. Voordat we onze conclusies presenteren, willen we een korte analyse doen van de werking van deze algoritmes.
2.1
Naive Bayes
Naive Bayes classificeert een willekeurige instantie met attributen x volgens Vergelijking 1. n
p (C = c) × ∏ p( X i = xi | C = c) i =1
Vergelijking 1 C is de getoetste klasse en X zijn de gegeven attributen van een bepaalde instantie. c een van de mogelijke uitkomsten is en x de attributen die bij deze uitkomst horen. [3]
Deze berekening wordt uitgevoerd voor alle mogelijke klassen; van deze uitkomsten kiest Naive Bayes het beste resultaat. Kort gezegd berekent het algoritme dus de uitkomst door het beste resultaat te kiezen uit een vermenigvuldiging van het aantal voorkomens van elke uitkomst en zijn onderlinge aantal keer dat ieder attribuut voorkomt. Terwijl deze methode bijna té simpel lijkt, levert het vaak een verrassend goede oplossing. Door zijn eenvoud, is Naive Bayes weerbaar tegen geïsoleerde ruispunten omdat uitspringers statistisch wegvallen. Naive Bayes werkt alleen het beste in twee extreme gevallen [5]:
• •
Datasets die uitsluitend geheel onafhankelijke features hebben, of Datasets die uitsluitend functioneel afhankelijke features hebben.
Gevallen die tussen deze extremen liggen verslechtert de prestatie van het algoritme. Kortom, bij datasets die attributen bevatten die afwisselend samenhangend of onafhankelijk zijn, levert een classificatie door Naive Bayes geen goed resultaat op.
2.2
C4.5
C4.5 is de opvolger van J. Ross Quinlan’s ID3 decision tree algoritme. Het algoritme begint met een set van instanties en maakt aan de hand daarvan een boomstructuur waarin nieuwe instanties kunnen worden geclassificeerd. Elke interne knoop van de boom bevat een test waarvan het resultaat bepaalt welke tak te volgen vanuit die knoop (de zogenaamde “divide-and-conquer algoritme”). De bladeren bevatten class labels in plaats van testen. Wanner tijdens het classificeren een instantie een blad bereikt zal C4.5 die instantie classificeren met de class van dat blad. Onder de verschillende algoritmen is C4.5 een van de beste doordat deze zorgt voor kleine accurate bomen, resulterend in snelle betrouwbare classifiers. Tijdens het testen kiest C4.5 de test welke het maximum aan informatie uit de instanties haalt, gegeven de voorwaarde dat maar één attribuut getest wordt. Een (grote) boom die 100% van de instanties goed classificeert hoeft niet per se beter te zijn dan een kleine boom waarin niet alle instanties passen. Daarom maakt C4.5 gebruik van pruning; het laten groeien van een grote boom om er vervolgens stukjes weer van te verwijderen. C4.5’s pruning methode is gebaseerd op het schatten van de error-rate van elke sub-boom en deze te vervangen met een blad als de geschatte fout lager is. Schat de error-rate van elke knoop in de boom, beginnend onderaan de boom. Als de schatting aangeeft dat de boom accurater zal zijn als de kinderen van knoop n verwijderd worden (en dat n een blad wordt) dan zal C4.5 n’s kinderen verwijderen. Als de schatting perfect is zal dit altijd tot een betere boom leiden. In praktijk (bij niet perfecte tot zelfs grove schattingen) leidt dit toch tot een beter resultaat.
2.3
Ripper
Repeated Incremental Pruning to Produce Error Reduction (RIPPER) bouwt de regelset één regel per ronde. Aan elke regel wordt door “divide and conquer” propositionele condities toegevoegd, net zoals bij C4.5. Ook voert Ripper hierna pruning uit om overfitting te verminderen.
Er geldt zowel bij C4.5 als Ripper dat de splitsing bij numerieke attributen anders werkt. Gezien het algoritme een splitsing over n takken moet maken, moet hij weten hoe de data gespreid ligt. In principe zou het algoritme alle instanties moeten doorwerken om dit te ontdekken, maar dit zou te lang duren; het zou immers O(n2) tijd kosten om enkel de spreiding van alle numerieke attributen te bepalen! Een eenvoudige oplossing is dat deze algoritmes uitgaan van een normale verdeling. Vaak leidt dit tot een redelijk resultaat, maar het is onbetrouwbaar. Ripper en C4.5 zijn daarom vaak niet goed te gebruiken bij datasets met veel numerieke attribuuttypes. [7] De tweede stap van het algoritme is waar Ripper van C4.5 verschilt. Daar waar C4.5 regels verwijdert, past Ripper ze aan in het belang van optimalisatie [2]. Er wordt per regel twee alternatieve candidaten gemaakt: de zogenaamde “vervangingsregel”, die vanuit een lege regel groeit, en “revisieregel”, die vanuit de huidige regel groeit. Samen met het orgineel wordt de regel met de kortste omschrijving gekozen en vervangt deze de oorspronkelijke regel.
2.4
Support Vector Machine
Het Support Vector Machine-algoritme (SVM) berust op het principe van het classificeren van data in een Rn ruimte door een hyperplane, en de margin tussen deze hyperplane en de punten te maximaliseren. Het kan echter soms moeilijk zijn om deze hyperplane te bepalen. SVM maakt gebruik van kwadratisch programmeren (QP) om per dimensie de margin te vergroten. Dit is een ingewikkelde berekening die vaak veel tijd kost, waardoor het bekend staat als een traag algoritme. Tevens is de classificatie ondoorzichtig; in tegen stelling tot C4.5 die een boom bouwt of Naive Bayes die de kansen op alle uitkomsten uitzet, moet men maar aannemen dat de berekening van de hyperplane uit de trainingset in SVM tot een optimaal resultaat levert. Ondanks dat de variant van SVM die geïmplementeerd is in Weka, (SMO), geoptimaliseerd is, zijn we sceptisch over het nut van deze oplossing omdat hij aanzienlijk trager is dan de anderen.
2.5
Boosting
Boosting is een algemene methode om weak learning algoritmes te verbeteren. Dit door middel van het herhaaldelijk rerunnen van een gegeven weak learning algoritme en daarvan de berekende classifiers combineren. Wat boosting doet is
dat het een hypothese genereert met weinig fouten in de training set. Dit doet hij uit de verschillende hypotheses (met veel fouten, maar beter dan ½) door ze te combineren. Boosting is nuttig als de dataset een variërende graad van moeilijkheid van classificatie heeft. Het boosting algoritme neemt als input een training set van m instanties. Daarnaast maakt boosting gebruik van een weak learning algoritme (in ons geval C4.5 en Decision Stumps). Het boosting algoritme roept herhaaldelijk het weak learning algoritme aan in verschillende rondes. Elke ronde voorziet de booster het weak learning algoritme van een verdeling instanties van de training set. Op zijn beurt geeft het weak learning algoritme een classifier voor die distributie van de training set. Deze classifier classificeert een fractie van de training set juist met grote waarschijnlijkheid ten opzichte van de verdeling. Het doel van het weak learning is om een hypothese te vinden welke de training error minimaliseert. Dit proces herhaalt zich een aantal ronden en uiteindelijk combineert de booster de verschillende zwakke hypothesen tot één laatste hypothese bijvoorbeeld door middel van stemmen. Door fout geclassificeerde instanties een groter gewicht te geven zullen ze bij opvolgende ronden eerder aan bod komen. Op deze manier focust boosting op de instanties die voor de weak classifier het moeilijkst zijn. 2.5.1
Adaboost met C4.5
Adaboost is de afkorting van ‘Adaptive Boosting’, en maakt dus gebruik van boosting. Omdat C4.5 ongewogen training instanties verwacht moeten deze eerst geresampled worden. Dit is een methode waar je van de set van voorbeeld instanties er een x aantal random pakt met terugleggen, op deze manier kan één instantie dus ook vaker voorkomen. Het voordeel van C4.5 is dat je in ieder geval wel zeker weet dat deze een error rate kleiner dan ½ zal hebben. Het gevaar bij Adaboost zit in het teveel gewicht leggen op noisy instanties, waar de classificatie onder lijdt. [1] 2.5.2
Adaboost met Decision Stumps
Het decision stump-algoritme berust op een classificatie volgens “single attribute discrimination”. In feite is het een beslisboom met maar één enkele knoop met de aan- of afwezigheid van een enkele term als predikaat. Voor elk attribuut A, toetst het algoritme een binaire splitsing en meet de score volgens score(A). De beste classificatie, splitsing door attribuut Ai, betekent volgens decision stumps dat score(Ai) maximaal is. [6]
2.6
Intermezzo: Bagging
Bootstrap aggrigating (‘bagging’) is een methode die herhaaldelijk willekeurige samples van een dataset neemt, met teruglegging, en een reeks classifiers maakt C0 t/m CN. Tot slot worden deze classifiers gecombineerd – door middel van voting – tot een enkele classifier C. Wordt N groot genoeg gekozen, is de kans dat een instantie uit de dataset gekozen wordt ca. 0.632 [1]. Het gevolg hiervan is dat naar verwachting een classifier gebouwd wordt die gebaseerd is op een willekeurige reeks van 63,2% unieke instanties uit de dataset. Deze methode zullen we niet toetsen, maar is een interessant alternatief op boosting, gezien deze zich minder focust op afwijkende waardes en dus minder gevoelig is voor ruis.
3.
Conclusies
3.1
Conclusie Naive Bayes
Naive Bayes is een buitengewoon snel algoritme die eenvoudig te implementeren is. Dit is al een flink voordeel, en bovendien is de classificatie vaak vrij redelijk. Bij de iris dataset leverde dit algoritme een verrassend goed resultaat op. De reden hiervoor is dat iris uitsluitend uit sterk samenhangende, numerieke attributen bestaat; daar waar Naive Bayes juist goed op presteert. Als we de data visualiseren in Weka, blijkt er hier en daar wat ruis zichtbaar. Uit de analyse van Naive Bayes weten we dat dit weinig invloed maakt op de classificatie. Op de vote en autos dataset doet Naive Bayes het significant slechter, dit komt doordat deze datasets noch sterk samenhangend noch sterk onsamenhangende attributen bevat.
3.2
Conclusies C4.5 en Adaboost met C4.5
C4.5 is zwakker als er een overwicht is aan continue (numerieke) waarden ten opzichte van de discrete (nominale) waarden [4]. Dit is het geval in de dataset autos. Waar C4.5 een (optimale) score van 83.52 haalt kan Adaboost dit nog boosten tot 86.39. Dit is een redelijke score, maar ten opzichte van de andere
datasets doen C4.5 en Adaboost met C4.5 het slecht op de autos dataset. Als we C4.5 of Adaboost met C4.5 uitvoeren op deze dataset, steekt het wél met kop en schouders uit boven de andere algoritmen. De reden hiervoor is dat C4.5 een sterk basis algoritme is; hij kan goed om gaan met noise (in tegenstelling tot Adaboost met Decision Stumps) en bouwt een betrouwbare classificatie zoals wij in practicum 1 waargenomen hebben. Aan de andere kant, presteert C4.5 bij iris niet bepaald goed. Onze analyse van deze dataset is dat deze zowel ruis als numerieke waarden bevat. Ruis is geen probleem voor dit algoritme, maar numerieke waarden wel. Wij bekeken nogmaals de werking van C4.5 en zagen dat hij tijdens de split er vanuit kan gaan dat numerieke waarden normaal verdeeld zijn. Dit is echter vaak niet het geval, waardoor hij een relatief slechtere classificatie zal geven. Of Weka daadwerkelijk deze assumptie maakt, wordt niet helemaal duidelijk uit zijn documentatie.
3.3
Conclusie Ripper
Uit de dataset iris blijkt dat Ripper slecht presteert met numerieke waarden. Dit heeft kennelijk iets te maken met de manier waarop dit algoritme attributen van dit type probeert te splitten. We weten dat Ripper en C4.5 dezelfde methode gebruiken voor de initiële split, en vermoeden dat hetzelfde probleem optreedt als eerder genoemd bij de conclusie van C4.5: Weka gaat uit van een normaal verdeelde dataset bij numerieke attributen. Uit de prestatie van deze algoritmes vergeleken met de anderen, kunnen we concluderen dat er bij iris echter geen sprake is van normaal verdeelde numerieke attributen.
3.4
Conclusie Support Vector Machine
Het idee achter SVM is dat data in Rn te classificeren is door middel van een hyperplane. Soms is het niet mogelijk om volgens dit eenvoudige principe data te scheiden. Bij iris is er een lineair verband zichtbaar tussen de meeste attributen. SVM slaagt erin om deze lineaire hyperplane zo te trekken dat het beste resultaat behaald wordt.
Bij vote en autos is er iets anders aan de hand. Hoewel we dit niet kunnen zien, vermoeden wij dat er kennelijk geen goed classificeerbaar lineair verband, polynomiaal verband of verband volgens een RBF-kernel mogelijk is.
3.5
Conclusie Adaboost met Decision Stumps
Adaboosting met Decision Stumps als basis algoritme doet het op autos zo slecht omdat er veel noise aawezig is. Het is opmerkelijk om te zien dat AdaBoost met decision stumps in de iris klasse het beter doet dan Adaboost met C4.5 omdat we er van uit gaan dat dit een beter basisalgoritme is. Toch doet Decision stumps het hier beter, waarschijnlijk door het al eerder genoemde probleem dat C4.5 slecht om kan gaan met een overwicht aan numerieke waarden. In iris is de ratio numeriek ten opzichte van nominaal 4:0 (zie tabel Tabel 1).
3.6
Conclusies Algemeen
Zoals in de tabel te zien is zijn voor veel classes gecombineerd met de verschillende algoritmen de standaard instellingen het beste. Dit komt omdat dit al redelijk optimale instellingen zijn. Het is wel mogelijk om wat class afhankelijke aanpassingen te maken, maar dit geeft toch maar minimale, zeker geen significante, verschillen. Het overall slechte presteren van de algoritmes op autos is waarschijnlijk te danken aan het feit dat deze zeven classes heeft (immers -3 t/m +3). De data is dan veel lastiger te classificeren. Op de iris dataset presteert SVM het allerbeste (zie Appendix, Figuur 1) met een classificatie van 96.27%. Echter, met 96.20% is Naive Bayes een goede tweede, en deze is aanzienlijk sneller in zijn berekening. Daar waar SVM 46 seconden aan het rekenen is doet Naive Bayes er slechts 1 seconde over om de dataset te classificeren. Dit in acht genomen, concluderen wij dat bij numerieke datasets zoals iris, Naive Bayes het beste algoritme is. Op de vote dataset presteert C4.5 het allerbeste (zie Appendix, Figuur 2) met de instelling dat er maar een minimum van één item per blad vereist is scoort hij 96.62% . Zoals we in het eerste practicum gezien hebben zorgt dit tevens voor een grotere boom. Adaboost me Decision Stumps, SVM, Ripper en Adaboost me C4.5 volgen snel met respectievelijk 96.39%, 95.86%, 95.75% en 95.72%. Alleen Naive Bayes scoort hier significant slechter. Op de autos dataset presteert Adaboost met C4.5 het allerbeste (zie Appendix, Figuur 3) met 20 in plaats van 10 iteraties en met een confidence
factor van 0.5. Adaboost met C4.5 doet het hier iets beter dan C4.5 los (83.52%) en Ripper (82.24%). Deze 3 algoritmen zijn alledrie significant beter dan SVM (76.84%), Naive Bayes (65.17%) en Adaboost met Decision Stumps (44.90%). Al onze resultaten zijn uitgezet in Tabel 2 van de Appendix.
4.
Appendix Iris
96.50
96.27
96.20
96.00 95.40
95.50
94.80
95.00
94.33
94.50
Iris 94.07
94.00 93.50 93.00 92.50 SVM RAW
NB -K
Adaboost Ds
C4.5 Unpruned
Adaboost J48
Jrip -F 4
Figuur 1 1. 2.
SVM Raw NB –K
3.
Adaboost DS
4. 5.
C4.5 Unpruned Adaboost J48
6.
Jrip –F 4
Small Vector Machine met standaard instellingen Naive Bayes met Kernel estimator voor numerieke waarden in plaats van nominale distributie Adaboost met Decision Stumps als weak learning algoritme en standard instellingen C4.5 met een unpruned boom Adaboost met J48 (C4.5 implementatie van Weka) als weak learning algoritme en standaard instellingen Ripper met 4 folds en de rest standaard instellingen
Vote 98.00 96.62
96.39
96.00
95.86
95.75
95.72
94.00
92.00
Vote 90.02
90.00 88.00 86.00 C4.5 Adaboost DS SVM -C -1.5 minNumObj -P 80 -I 40 1
Ripper
Adaboost J48 -P 80
NB RAW
Figuur 2 1. 2.
C4.5 minNumObj 1 Adaboost DS –P 80 –I 40
3. 4. 5.
SVM –C -1.5 Ripper Adaboost J48 –P 80
6.
NB Raw
C4.5 Algoritme met een minimum van 1 object per blad Adaboost met Decisions Stumps als weak learning algoritme met als bodemgrens van het gewicht tijdens het prunen op 80 en 40 iteraties Small Vector Machines met complexiteit parameten 1.5 Ripper met standaard instellingen Adaboost met J48 (C4.5 implementatie van Weka) als weak learning algoritme met als bodemgrens van het gewicht tijdens het prunen op 80 Naive Bayes met standaard instellingen
Autos 100 86.39
90
83.52
82.24 76.84
80
65.17
70 60
44.90
50
Autos
40 30 20 10 0 Adaboost J48 C4.5 Jrip -F 3 -N SVM -E 2.0 conf 0.5 -I 20 minNumObje 2.0 -0 4 -S 1 1 -P
NB -D
Adaboost DS
Figuur 3 1.
Adaboost J48 conf 0.5 –I 20
2.
C4.5 minNumObje 1
3.
Jrip –F 3 –N 2.0 –O 4 –S 1 –P
4.
SVM –E 2.0
5.
NB –D
6.
Adaboost DS
Adaboost met J48 (C4.5 implementatie van Weka) als weak learning algoritme met confidence factor 0.5 en 20 iteraties C4.5 Algoritme met een minimum van 1 object per blad Ripper met 3 folds, minimum van 2 objecten per blad (standaard), 4 optimaliseer runs, 1 seed voor de random data (standaard) en unpruned Small Vector Machines met als exponent van de polynomiale kernel 2.0 Naive Bayes met supervized discretization om numerieke attributen nominaal te maken Adaboost met Decision Stumps als weak learning algoritme en standard instellingen
Algoritme Naive Bayes
Support Vector Machine
Ripper
C4.5
Adaboost met Decision Stumps
Adaboost met C4.5
Tabel 2
Instelling Standaard Kernel Estimator Supervized Discretization Standaard Complexity 1.5 RBF Kernel met Gamma 0.01 RBF Kernel met Gamma 0.10 RBF Kernel met Gamma 0.01 Complexity 1.5 Exponent voor de Polynomiale Kernel 0.5 Exponent voor de Polynomiale Kernel 1.5 Exponent voor de Polynomiale Kernel 2.0 Exponent voor de Polynomiale Kernel 2.5 Standaard 4 Folds 5 Folds Min. 3 inst. per blad Min. 4 inst. per blad 3 optimalisatie ronde 4 optimalisatie ronde 4 optimalisatie ronde, Unpruned Standaard Unpruned Confidence factor 0.50 Confidence factor 0.75 Confidence factor 1.00 Minimale # instanties in 1 blad op 1 Binary split op nominale attributen Standaard Min. gewicht = 80 Min. gewicht = 120 Min. gewicht = 80 en 40 Resampling i.p.v. Reweighting Resampling i.p.v. Reweighting, 5 iteraties Resampling i.p.v. Reweighting, 15 iteraties 20 iteraties 40 iteraties Standaard Unpruned Min. 1 inst. per blad, Min. gewicht 80, 40 iteraties Confidence factor 0.5 Confidence factor 0.5 en 20 iteraties Confidence factor 0.5 en 40 iteraties Confidence factor 0.5, Resampling i.p.v. Reweighting, 20 iteraties Confidence factor 0.5, Resampling i.p.v. Reweighting, 40 iteraties Min. 1 inst. per blad Binary split Min. gewicht 80 Min. gewicht 120 5 iteraties 15 iteraties
Iris 95.53 96.20 93.33 96.27 95.93 88.07 95.13 89.00 95.53 95.53 95.53 93.73 93.93 94.07 93.80 93.13 93.07 93.73 94.07 92.60 94.73 94.80 94.73 94.80 94.80 94.13 94.73 95.40 93.93 94.23 – 94.00 94.20 94.07 – – 94.33 94.27 – 94.27 – – –
Vote 90.02 90.02 90.02 95.77 95.93 94.69 95.59 94.94 94.92 95.86 94.50 94.66 95.75 95.63 95.68 95.52 95.47 95.75 95.75 94.87 96.57 95.76 96.57 95.86 95.86 96.62 96.57 95.43 95.79 95.51 96.39 95.12 94.57 94.98 96.39 96.23 95.51 95.05 95.47 95.35 95.37 95.40 –
Autos 57.41 61.33 65.17 71.34 71.08 44.80 62.94 49.20 61.51 76.30 76.84 76.69 73.62 74.64 74.08 69.56 68.33 74.30 75.25 82.24 81.77 82.40 81.86 82.59 82.59 83.52 78.90 44.90 44.90 44.90 – 43.39 43.39 43.39 – – 85.46 84.33 86.04 86.39 86.39 85.16
–
–
86.59
94.07 94.33 93.93 94.33 94.20 94.20
95.40 95.51 95.72 95.51 95.40 95.21
85.67 84.73 84.44 84.73 84.48 85.08
5.
Referenties
[1] Bauer, E., & Kohavi, R. (1999). An empirical comparison of voting classification algorithms: Bagging, boosting and variants. Machine Learning. 36 (1999) 105-139. [2] Frank, E., & Witten, I. H. (1998). Generating accurate rule sets withoug global optimization. Proc 15th International Conference on Machine Learning. 144-151. [3] John, G. H. & Langley, P. (1995). Estimating Continuous Distributions in Bayesian Classifiers. Stanford University. [4] Quinlan, J. R. (1996). Improved use of Continuous Attributes in C4.5. Journal of Artificial Intelligence Research. 4 (1996) 77-90. [5] Rish, I., Hellerstein, J., & Thathacher, J. (2001). An analysis of data characteristics that affect naive Bayes performance. IBM TJ. Watson Research. [6] Wayne Ida, Pat Langley (1992). Induction of One-Level Decision Trees. NASA Ames Research Center (1992). [7] Yıldız, T., & Alpaydın, E. (2004). Learning Rules from Data. Boğaziçi University.
