Exercices arbres de décision (8.3)

Exercice 19

L'objectif de l'exercice est de montrer le pouvoir d'expression des arbres de décision en montrant que toute fonction Booléenne de n variables peut être représentée par un arbre de décision. Notez que cet arbre peut être grand.

La fonction and peut être représentée par l'arbre de décision [x=0](0,[y=0](0,1)) où on a le test [x=0] (ou [x=FAUX]) en racine, sur la première branche, on a la valeur 0 car, quel que soit la valeur de y, la fonction and prend la valeur 0 (ou FAUX), sur la seconde branche, on a le test [y=0] et une première branche avec la valeur 0 (car and(1,0)=0) et une seconde branche avec la valeur 1 (ou VRAI) car and(1,1)=1 (ou and(VRAI,VRAI)=VRAI). Notez que cette représentation n'est pas unique car on aurait pu choisir en racine de mettre le test [y=0]. De même, la fonction or peut être représentée par l'arbre de décision [x=0]([y=0](0,1),1). Enfin, la fonction xor peut être représentée par l'arbre de décision [x=0]([y=0](0,1),[y=0](1,0)).
La fonction and peut être représentée par l'arbre de décision [x=0](0,[y=0](0,[z=0](0,1))). La fonction or peut être représentée par l'arbre de décision [x=0]([y=0]([z=0](0,1),1),1).
Un arbre petit est [x=1](1,[y=0](0,[z=0](0,1))).
Toute fonction Booléenne sur n variables x1, ..., xn peut être représentée par un arbre de décision. Par exemple, à la racine, on choisit le test [x1=0], pour les deux fils, on choisit le test [x2=0], on réitère le procédé jusqu'à xn. On obtient un arbre binaire qui a 2^n feuilles et où chaque feuille correspond à un choix d'attribution de valeurs à x1, ..., xn. Par exemple, la feuille la plus à gauche correspond au choix x1=x2=...=xn=0 et la feuille la plus à droite correspond au choix x1=x2=...=xn=1. Il suffit alors de décorer l'arbre aux feuilles par les valeurs de la fonction considére pour le n-uplet de valeurs choisies sur le chemin correspondant de la racine à cette feuille. Par exemple, cette construction donnerait pour la fonction and à deux variables l'arbre de décision [x=0]([y=0](0,0),[y=0](0,1)) et pour la fonction or à trois variables [x=0]([y=0]([z=0](0,1),[z=0](1,1)),[y=0]([z=0](1,1),[z=0](1,1))). Notez que nous avons trouvé des formes plus simples dans les questions 1 et 2. Notez également que la fonction xor à deux variables peut être représentée par l'arbre de décision [x=0]([y=0](0,1),[y=0](1,0)) et que vous ne pouvez pas trouver de forme plus simple (avec moins de trois tests).

Exercice 20

L'objectif de l'exercice est de montrer que les arbres de décision permettent de construire des règles de classement complexes en utilisant des droites parallèles aux axes alors qu'un séparateur linéaire est constitué d'une seule droite mais non nécessairement parallèle à un axe.

L'échantillon S1 est repésentable par un arbre de décision avec des tests de la forme [x<k] et [y<k] car ces tests correspondent à tracer des droites parallèles aux axes. Les points noirs sont délimités par les segments de droite reliant les points (0,1) et (1,1), (1,1) et (1,3), (1,3) et (3,3), (3,3) et (3,1), (3,1) et (4,1). Une représentation par arbre de décision est [y<1](noir,[y<3]([x<3]([x<1](blanc,noir),blanc),blanc). On voit graphiquement que l'échantillon S1 n'est pas linéairement séparable.
L'échantillon S2 est linéairement séparable car on peut trouver une droite qui sépare les points noirs des points blancs. L'échantillon S2 n'est pas représentable par un arbre de décision avec des tests de la forme [x<k] et [y<k] avec k entier.
Par contre, il est linéairement séparable par un arbre de décision avec des tests de la forme [x<k] et [y<k] avec k réel. Il suffirait de construire un "escalier" qui sépare les points noirs des points blancs. L'arbre de décision serait assez compliqué (avec beaucoup de tests). L'escalier aurait une forme compliquée adaptée aux points de l'échantillon et son pouvoir de généralisation laisse des doutes.
On pourrait penser considérer des tests plus complexes que des tests de la forme [x<k] et [y<k] avec k réel mais cela rendrait l'ensemble des tests beaucoup plus expressif et l'algorithme d'apprentissage des arbres de décision devrait être adapté avec une recherche d'un bon test qui serait plus complexe. Si cette méthode a été considérée dans des papiers de recherche, elle n'a jamais été vraiment déployée car amenant à des algorithmes trop peu efficaces.

Exercice 21

Cet exercice est une vérification de compréhension de ce qu'est un arbre de décision et comment un arbre classe des exemples.

Prenons l'exemple 1. Pour le classer avec l'arbre t3 qui a l'attribut Outlook en racine, on regarde la valeur de l'attribut Outlook pour l'exemple 1 qui est humidity donc on descend sur la première branche de l'arbre. Il faut donc maintenant regarder la valeur de l'attribut humidity pour l'exemple 1 qui est 78, on descend sur la première branche. On trouve un noeud réduit à une classe N. L'arbre t3 classe donc l'exemple 1 dans la classe N. Cet exemple est bien classé car la classe à prédire est bien la classe N. On procède de même pour les autres exemples pour vérifier que t3 classe correctement tous les exemples de l'échantillon.
L'arbre t1 correspond à classer tous les exemples dans la classe P. L'arbre t1 correspond à la règle majoritaire. Son erreur apparente est 5/14 ~ 35.71%. On classe les exemples avec t2, on trouve 4 erreurs donc l'erreur apparente est 4/14 ~ 28.57%. Pour t3, son erreur apparente est 0%.

Exercice 22

Cet exercice a pour objectif de bien faire comprendre l'importance du choix de l'ordre de sélection des attributs dans la construction d'un arbre de décision et donc pourquoi un algorithme de construction doit choisir un ordre.

Je choisis d'ordonner les branches de l'arbre dans l'ordre [P3=O], [P3=I] et [P3=N] pour P3, [P2=V] et [P2=F] pour P2 et [P1=0] et [P1=1] pour P1. Avec ce choix, si on construit un arbre de décision parfait avec l'ordre P3, P2, puis P1, on obtient l'arbre de décision t1 = P3(P2(A, B), A, P2(A, P1(B,A))).
Avec l'ordre P1, P2, P3, on obtient l'arbre de décision t2 = P1(P2(A, B), A).
On constate que t2 est bien plus simple que t1. Choisir le test P1 en racine est intéressant car si P1 vaut 1, tous les exemples correspondants sont de classe A. Pour la branche correspondant au test [P1=0], il suffit de regarder la valeur de P2 pour bien classer les exemples de cette branche.
Il n'existe pas d'arbre parfait car deux exemples de même description (1,V,I) sont l'un de classe A et l'autre de classe B. Cet exemple est simpliste mais il faut bien comprendre que dans des jeux de données en vraie grandeur ce phénomène se produit et il peut être impossible de trouver un arbre d'erreur apparente nulle.

Exercice 23

Cet exercice a pour objectif de faire comprendre, par l'exemple, les fonctions de degré de mélange et d'introduire la fonction gain.

On peut décorer l'arbre avec les effectifs à chacune des positions de l'arbre. Pour la racine, on a la répartion (100,100). Pour le noeud 1 (le premier fils de la racine) on a la répartition (97,38) et pour le noeud 2 (le deuxième fils de la racine) on a la répartition (3,62). Pour le noeud 1.1 (le premier fils du premier fils de la racine) on a la répartition (6,37) et pour le noeud 1.2 (le deuxième fils du premier fils de la racine) on a la répartition (91,1).

Pour le cas à deux classes (classification binaire), la fonction de Gini s'écrit Gini(x)=2x(1-x) où x est la proportion d'exemples d'une des deux classes. Ceci nous donne Gini(epsilon)=2x100/200x100/200 = 0.5 qui est la valeur maximal obtenue lorsque les exemples sont répartis également entre les deux classes. Gini(1) = 2x97/135x38/135 ~ 0.40. Gini(2) = 2x3/65x62/65 ~ 0.09 qui est proche de 0 car les exemples sont presque tous dans une même classe. Gini(1.1) = 2x6/43x37/43 ~ 0.24. Gini(1.2) = 2x1/92x91/92 ~ 0.02. Cet exemple montre bien en quoi la fonction de Gini mesure le degré de mélange entre les deux classes : une valeur grande à la racine où les exemples sont équi-répartis ; une valeur très petite au noeud 1.2 où tous les exemples, sauf 1, sont d'une même classe ; et des valeurs intermédiaires aux autres noeuds.
Pour le cas à deux classes (classification binaire), la fonction de Gini s'écrit Gini(x) = -xlog(x) - (1-x)log(1-x) où x est la proportion d'exemples d'une des deux classes. Il existe différentes fonctions logarithme (Néperien soit base e ou en base 2 ou en base 10). Le choix importe peu (à condition de se fixer sur un choix, bien entendu !) car les résultats diffèrent d'une constante. Je donne les résultats avec la fonction logarithme Néperien. entropie(epsilon) = -100/200 log(100/200) - 100/200 log(100/200) = log(2) ~ 0.69 ; entropie(1) = -97/135log(97/135) - 38/135log(38/135= ~ 0.59 ; entropie(2) ~ 0.19 ; entropie(1.1) ~ 0.40 ; entropie(1.2) ~ 0.06. Vérifiez que vous retrouvez les mêmes caractéristiques que pour la fonction de Gini pour la mesure du degré de mélange.
Supposons qu'il nous faille construire un arbre de décision au vu des répartitions d'un échantillon données dans la figure 8.8. Il faut choisir une racine entre tester si le patient a la gorge irritée ou si le patient a de la température. Si on choisit la température, on aura un arbre avec des répartitions pour chacun des deux fils qui sont (97,38) et (3,62). Si on choisit la gorge irritée, on aura un arbre avec des répartitions pour chacun des deux fils qui sont (8,58) et (92,42). Nous avons peut être une préférence sur la température au vu de ses répartitions. Voyons ce que nous donne le calcul de gain. Il est effectué avec la fonction de Gini. Le gain de mettre le test température à la racine de l'arbre, noté gain(racine , température<37.5), s'exprime sous la forme 0.5 - [135/200x2x97/135x38/135 + 65/200x2x3/65x62/65] = 0.5 - 0.301 = 0.199. Le gain de mettre le test gorge irritée à la racine de l'arbre, noté gain(racine , gorge irritée), s'exprime sous la forme 0.5 - [66/200x2x8/66x58/66 + 134/200x2x42/134x92/134] = 0.5 - 0.358 = 0.142. On cherche à maximiser le gain donc le critère du gain maximum nous dit de choisir le test sur la température.

Exercice 24

Cet exercice a pour objectif d'appliquer l'algorithme d'apprentissage d'arbres de décision.

Il suffit d'appliquer les règles de discrétisation données dans l'énoncé.
A la racine, on a le choix entre les quatre tests correspondant aux quatre attributs. Le test ternaire sur l'attribut Outlook avec dans l'ordre sunny, overcast et rain qui mène aux répartitions (3,2) soit 3N et 2P pour le noeud correspondant à Outlok=sunny, (0,4) pour le noeud correspondant à Outlook=overcast et (2,3) pour le noeud correspondant à Outlok=rain. Le test ternaire sur l'attribut Temperature avec dans l'ordre cool, mild et hot qui mène aux répartitions (1,3) pour le noeud correspondant à Temperature=cool, (2,4) pour le noeud correspondant à Temperature=mild et (2,2) pour le noeud correspondant à Temperature=hot. Le test binaire sur l'attribut Humidity avec dans l'ordre normal et high qui mène aux répartitions (1,5) pour le noeud correspondant à Humidity=normal et (4,4) pour le noeud correspondant à Humidity=high. Enfin le test binaire sur l'attribut Windy avec dans l'ordre true et false qui mène aux répartitions (3,3) pour le noeud correspondant à Windy=true et (2,6) pour le noeud correspondant à Windy=false. On écrit les gains correspondants (ici avec l'entropie). On a Gain(epsilon,Outlook) = entropie(epsilon)-[5/14 entropie(1) + 4/14 entropie(2) + 5/14 entropie(3)] = entropie(epsilon)-[5/14 (-3/5 log(3/5) - 2/5 log(2/5)) + 4/14 x 0 + 5/14 (-3/5 log(3/5) - 2/5 log(2/5))] = entropie(epsilon) - 0.48. De la même façon, on trouve Gain(epsilon,Temperature) = entropie(epsilon) - 0.63 ; Gain(epsilon,Humidity) = entropie(epsilon) - 0.59 ; Gain(epsilon,Windy) = entropie(epsilon) - 0.62. Le gain maximal est obtenu pour l'attribut Outlook. Il est choisi comme racine de l'arbre. On réitère le même procédé pour chacun des trois noeuds obtenus en calculant le gain pour choisir entre les trois attributs restants. Un peu fatigués, nous allons le faire "à la main". Au noeud 1, l'attribut Humidity classe parfaitement les exemples en ce noeud, il sera donc choisi. Au noeud 2, tous les exemples sont correctement classés donc c'est un noeud de décision avec la classe P. Au noeud 3, l'attribut Windy classe parfaitement les exemples, donc on choisit cet attribut. On obtient en sortie de l'algorithme l'arbre Outlook(Humidity(N,P),P,Windy(N,P)).
Supposons qu'on soit à la racine de l'arbre et qu'on considère l'attribut Temperature. On ordonne les valeurs de cet attribut et on regarde la classe de l'exemple correspondant. On trouve la série 64:N, 65:P, 68:P, 69:P, 70:P, 71:P, 72:N, 73:N, 75:P, 75:P, 80:N, 81:N, 83:P, 85:P. On choisit les valeurs entre des changements de classe ce qui nous donnera les tests Temperature<64.5, Temperature<71.5, Temperature<74, Temperature<77.5 et Temperature<82. Ces tests seront considérés dans la compétition pour choisir les tests. Notez que cette méthode permet à l'algorithme de traiter directement (c'est-à-dire sans les discrétiser a priori) les attributs continus. Notez aussi que les tests considérés sont différents au cours de la construction de l'arbre car l'ensemble des exemples à chaque noeud est différent. Par exemple, si on commence à construire l'arbre et qu'on choisit l'attribut Outlook, aux noeuds 1 et 2 les ensembles d'exemples sont différents et on va recalculer les tests sur l'attribut Temperature avec la méthode précédente sur chacun de ces ensembles d'exemples. Pour l'attribut Humidity à la racine, vérifiez que vous trouvez les tests Humidity<69.5, Humidity<71, Humidity<77.5, Humidity<79, Humidity<81, Humidity<93.

Exercice 25

L'objectif est de montrer le problème des attributs discrets avec un grand nombre de valeurs.

Si on considère l'attribut num dans la description des exemples, cet attribut définit un arbre à 14 branches correspondant aux tests [num=1], ..., [num=14]. Chaque branche contient un seul exemple et donc d'une seule classe. Tous les exemples dans chacune des branches sont donc ien classés et le gain sera maximal car on obtient, en choisissant l'attribut num, un arbre parfait ! C'est bien évidemment un mauvais choix de classer des exemples en regardant leur numéro ! Le numéro d'exemple n'est jamais inclus dans la description des exemples dans les systèmes d'apprentissage.
Le ratio de gain a été introduit pour éviter de privilégier les tests ayant un grand nombre de branches commes les tests définis par un attribut discret ayant un grand nombre de valeurs. Sur notre exemple, SplitInfo(epsilon, num) = -1/14log(1/14) - ... - 1/14log(1/14) = log(14) ~ 2.64. Nous considérons l'attribut Outlook qui procure le meilleur gain (exercice 24). On a SplitInfo(epsilon, Outlook) = -5/14log(5/14) - 4/14log(4/14) - 5/14log(5/14) ~ 1.09. Le ratio de gain divise le gain par cette quantité SpliInfo et on voit donc que l'attribut num va être pénalisé par rapport à l'attribut Outlook. Les calculs nous donnent GainRatio(epsilon,num) = (entropie(epsilon)-0)/2.64 ~ 0.26 et GainRatio(epsilon,Outlook) = (entropie(epsilon)-0.48)/1.09 ~ 0.20. L'attribut num l'emporte quand même ! Cependant il faut noter que notre exemple est un exemple jouet avec seulement 14 exemples. Avec 100 exemples, SplitInfo(epsilon, num) vaudrait log(100) ~ 4.6 et GainRatio(epsilon,num) = (entropie(epsilon)-0)/4.6 ~ 0.15 et num ne serait pas choisi.

Exercice 26

L'objectif est de comprendre les avantages et inconvénients d'un algorithme glouton comme l'agorithme d'apprentissage des arbres de décision.

Le gain de A est gain(epsilon,A) = entropie(epsilon) - [1/2 entropie(1) + 1/2 entropie(2)]. Mais entropie(epsilon) = entropie(1) = entropie(2) = log(2). Donc gain(epsilon,A) = 0. De même, gain(epsilon,B) = 0. On trouve deux gains nuls donc on ne sait pas choisir. On pourrait même décider d'arrêter car aucun des deux attributs n'aide à classer les exemples.
Supposons qu'on choisisse A et qu'on décide poursuivre la construction, on obtient alors l'arbre de décision [A=VRAI]([B=VRAI](2,1),[B=VRAI](1,2)) qui est un arbre de décision parfait ! Il ne fallait pas s'arrêter !
Si les attributs A et B sont parmi un ensemble d'autres attributs, il est fort probable que l'algorithme choisisse parmi ces autres attributs et il est possible que l'algorithme construise un arbre de décision de grande taille alors qu'il existe un arbre de profondeur 2 parfait ! L'algorithm ne trouvera pas l'arbre parfait de la question précédente. Ceci montre que l'algorithme vu en cours n'est pas optimal dans le sens qu'il ne trouve pas le plus petit arbre d'erreur faible (ce problème étant de complexité trop élevée pour être calculé par un algorithme). En effet, l'algorithme vu en Section 3 est glouton car il recherche le meilleur test dans chaque noeud et il ne remet jamais en question un choix effectué à une étape précédente.
Les idées possibles pour améliorer l'algorithme sont : autoriser des explorations à une profondeur plus grande (c'est-à-dire ne pas se mimiter à un test mais choisir plusieurs tests), autoriser à revenir sur un choix précédent. Ces idées ont été explorées mais n'ont débouché sur aucune solution satisfaisante pour au moins deux raisons : sur les problèmes réels, les gains en performance sont trop minimes par rapport à la complexité croissante des algorithmes (au lieu de choisir parmi N tests, il faut choisir parmi N^3 arbres de tests); d'un point de vue théorique, si on décide d'examiner des arbres de profondeur 2, on peut construire un problème qui nécessite un arbre de profondeur 3, et ainsi de suite.

Exercice 27

La procédure majoritaire associe à tout exemple la classe 0. Son erreur apparente est de 30%

On voit que l'attribut A ne permet pas d'aider à classer dans aucune des deux branches donc cet attribut ne sera pas choisi.
Gain(B) = Gini(epsilon) - [350/500 x 2 x 50/350 x 300/350 + 150/500 x 2 x 50/150 x 100/150] ~ Gini(epsilon-0.3 ; Gain(C) = Gini(epsilon) - [70/500 x 2 x 10/70 x 60/70 + 90/500 x 2 x 10/90 x 80/90 + 340/500 x 2 x 60/340 x 280/340] = Gini(epsilon) - 0.27. On choisit donc l'attribut C.

Exercice 28

Il y a 217 exemples de classe + et 273 exemples de classe - donc la procédure majoritaire associe à tout exemple la classe -. Son erreur en apprentissage est 217/490 ~ 44.29%. Son erreur en test est 90/200 = 45%.
L'arbre avant élagage contient 115 tests de décision, l'arbre après élagage contient 43 tests de décision. L'erreur apparente mesurée sur l'ensemble d'apprentissage est de 3.1% sur l'arbre avant élagage et 5.9% sur l'arbre après élagage. L'estimation de l'erreur réelle est donnée par l'erreur apparente mesurée sur l'ensemble test, elle est de 19.5% sur l'arbre avant élagage et 20% sur l'arbre après élagage. On constate bien que l'erreur mesurée sur l'ensemble d'apprentissage est optimiste. On vérifie également que l'arbre élagué est bien plus simple (taille divisée par 3) tout en ayant une erreur réelle estimée très proche. Notez que parfois l'arbre élagué peut être meilleur que l'arbre non élagué.
On regarde l'attribut A9 qui vaut f donc on trouve la classe -. Dans ce noeud, on a un effectif de 239 exemples dont 19.4 sont mal classés. Le nombre décimal d'exemples provient du fait que l'échantillon contient des valeurs manquantes et qu'on utilise la méthode de l'exercice 29 dans ce cas.
Changer la valeur de l'attribut A11 ne change pas le classement. Prenons par contre un exemple tel que A9=t ; A15=385 ; A11=2.25 ; A14=98 et A5=gg. Un tel exemple arrive sur une feuille classée + d'effectif 0. On choisit la classe + car c'est la classe majoritaire du noeud père.

Exercice 29

L'objectif de l'exercice est d'introduire la méthode de gestion des valeurs manquantes de C4.5 après avoir vu deux méthodes de pré-traitement.

On remplace les valeurs manquantes par grand car il y a 5 grand et 3 petit. On ne peut pas trouver d'arbre sans erreur car il y a deux exemples contradictoires (un de classe oui et un de classe non) de description (carré, grand, blanc). Si on choisit le test forme on a la répartition rond (4,0) et carré (3,3), si on choisit l'attribut taille on a la répartition petit (3,0) et grand (4,3), si on choisit l'attribut couleur on a la répartition bleu (3,1), blanc (3,1) et rouge (1,1). On écrit les formules de gain et le test sur la taille l'emporte. On trouve l'arbre écrit sous forme de règles : si taille = petit alors oui ; si taille = grand et forme = rond alors oui ; si taille = grand et forme = carré et couleur= bleu ou rouge alors non ; si taille = grand et forme = carré et couleur = blanc alors ?, on peut choisir oui qui est maloritaire.
La valeur majoritaire de l'attribut pour la classe oui est petit, pour la classe non, la valeur majoritaire de l'attribut est grand. Donc on remplace le ? par petit pour les deux exemples qui sont de classe oui. On peut trouver un arbre sans erreur car il n'y a pas d'exemples contradictoires. Si on choisit l'attribut taille on a la répartition petit (5,0) et grand (2,3). On écrit les formules de gain et le test sur la taille l'emporte.
On ne modifie pas l'algorithme d'apprentissage. On modifie simplement les méthodes de compte d'effectifs en autorisant des nombres réels. Les formules de calcul de gain restent identiques.

Exercice 30

L'exercice présente la méthode d'élagage utilisée dans C4.5. Contrairement à la méthode présentée dans l'ouvrage qui utilise un ensemble test ou la validation croisée, la méthode présentée ici se base sur des estimations statistiques pessimistes de l'erreur réelle dans chacun des noeuds de l'arbre. L'exercice est un exercice de compréhension et il suffit d'appliquer les formules présentées. Si vous utilisez C4.5 ou une variante, il faut retenir que le coefficient CF mesure une confiance dans l'estimation et que CF influe sur la force de l'élagage. Par défaut CF est égal à 25%, et plus CF est petit plus l'élagage est fort : CF voisin de 0 conduit à élaguer fortement jusqu'à obtenir un arbre réduit à une feuille qui correspond à la règle majoritaire, CF voisin de 100% conduit à ne pas élaguer (ou très peu).

Exercice 31

L'exercice est une application de l'algorithme de vote de majorité pondéré. Les trois experts commencent avec des poids égaux à 1 ce que nous notons a=b=c=d=1.

On présente la valeur 0 sur lequel A prédit +1, B prédit -1, C prédit +1 et D prédit -1 et que la vraie classe est -1 (0 n'appartient pas au concept cible qui est l'intervalle [3,6]). On applique la règle de mise à jour des poids : les poids de B et D qui ont prédit correctement sont inchangés, les poids de A et C qui se sont trompés sont multipliés par 1/2. Donc après avoir vu 0 et révélé sa vraie classe, les poids sont désormais a=1/2, b=1, c=1/2 et d=1.
On présente la valeur 5, tous les experts prédisent correctement donc les poids sont a=1/2, b=1, c=1/2 et d=1.
On présente la valeur 7, seul A se trompe, donc les poids sont a=1/4, b=1, c=1/2 et d=1.
On présente la valeur 2, seul D prédit correctement, donc les poids sont a=1/8, b=1/2, c=1/4 et d=1.
On présente la valeur 4, seul B se trompe, donc les poids sont a=1/8, b=1/4, c=1/4 et d=1.
On présente la valeur 5, tous les experts prédisent correctement donc les poids sont a=1/8, b=1/4, c=1/4 et d=1.
On présente la valeur 8, seul A se trompe, donc les poids sont a=1/16, b=1/4, c=1/4 et d=1.
On présente la valeur 1, seul D prédit correctement, donc les poids sont a=1/32, b=1/8, c=1/8 et d=1.
On présente la valeur 3, seul B se trompe, donc les poids sont a=1/32, b=1/16, c=1/8 et d=1.

Après cette présentation d'exemple, D a un poids de 1 (il ne se trompe jamais !). A et D ont des poids faibles car ils ont des prédictions indépendantes des données.

Exercice 32

Dans les formules utilisées, il suffit de remplacer les nombres d'exemples (et les proportions) par des sommes de poids (et les proportions correspondantes). Notez que pour les valeurs manquantes, nous avions déja signalé qu'on pouvait remplacer des comptes entiers par des comptes réels.