Partie III Expérimentation et Évaluation
Chapitre 7 Complexité de classement d’objets avec valeurs manquantes 127
7.3 Complexité de classement d’objet dans un arbre de décision
7.3.1 Complexité de notre algorithme de classement
Pendant le processus de classement, quand nous rencontrons une valeur manquante pour un attribut-noeud, nous appelons son arbre d’attribut72 pour calculer sa probabilité. De la même manière, si nous rencontrons un autre attribut manquant dans cet arbre, nous devons appeler son arbre d’attribut, et ainsi de suite. A la fin du processus de classement, nous remarquons que nous avons appelé plusieurs arbres d’attributs. Le calcul de probabilité de chaque attribut man-quant n’est pas arbitraire. Nous commençons toujours par traiter l’attribut le moins dépendant de la classe.
Exemple. Nous allons expliquer la complexité de notre algorithme de classement en utilisant
un exemple de la base météo [Quinlan, 1993].
Dans cette base, nous avons 5 attributs : 1) Temps, qui prend les valeurs {ensoleillé, couvert, pluvieux} ; 2) Température, qui prend également 3 valeurs {élevée, moyenne, basse} ; 3)
Humi-dité prend 2 valeurs {haute, normale} ; 4) Vent prend les valeurs {vrai, faux} ; 5) Décision est
l’attribut classe et prend les valeurs {A, B}.
Considérons le classement d’un objet dont Temps, Température et Humidité sont manquants,
Vent est faux. Nous commençons de la racine de l’arbre donné dans la figure 7.5 en parcourant
les chemins correspondant aux valeurs de l’attribut manquant Temps jusqu’à ce qu’on arrive à une feuille. Parce que Humidité est également manquante, nous parcourons 4 chemins dans cet arbre.
Nous calculons la probabilité que cette instance appartienne à la classe A comme suit : P (A) = P(A|ensoleillé, haute) * P(ensoleillé, haute) (7.6)
+ P(A|ensoleillé, normal) * P(ensoleillé, normal) + P(A|couvert) * P(couvert)
+ P(A|pluvieux, faux) * P (pluvieux, faux) 72
7.3. Complexité de classement d’objet dans un arbre de décision
PSfrag replacements σIM¯r(A,C)≥ 0.0315 miss value rate≥ 20 yes σIM¯r(A,C)≥ 0.0315 no miss value rate≥ 20 yes miss value rate≥ 20
¯ IMN(A, C)≤ 0.646 no ¯ IMN(A, C)≤ 0.646 yes ¯ IMN(A, C)≤ 0.646 no U N SET U N SET W IN S W IN S (3) Haute
0.75 (1) Normale 0.25 (4) Normale 1.0 (4) Haute 0.66 (2) Normale 0.33 (14) Température (4) Humidité élevée (4) Humidité basse (6) Humidité moyenne PSfrag replacements σIM¯r(A,C)≥ 0.0315 miss value rate≥ 20 yes σIM¯r(A,C)≥ 0.0315 no miss value rate≥ 20 yes miss value rate≥ 20
¯ IMN(A, C)≤ 0.646 no ¯ IMN(A, C)≤ 0.646 yes ¯ IMN(A, C)≤ 0.646 no U N SET U N SET W IN S W IN S
Fig. 7.3 – L’AAOP de Température et l’AAOP d’Humidité PSfrag replacements
σIM¯r(A,C)≥ 0.0315 miss value rate≥ 20 yes σIM¯r(A,C)≥ 0.0315 no miss value rate≥ 20 yes miss value rate≥ 20
¯ IMN(A, C)≤ 0.646 no ¯ IMN(A, C)≤ 0.646 yes ¯ IMN(A, C)≤ 0.646 no U N SET U N SET W IN S W IN S
Fig.7.4 – L’AAP de Temps
(3) A 1.0 (0) A 0.0 (0) A 0.0 (0) B 0.0 (2) B 1.0 (4) B 1.0 (2) A 1.0 (0) B 0.0 (0) A 0.0 (3) B 1.0 (14)Temps (5)Humidité ensoleillé (4) Decision couvert (5) vent pluvieux (3)Decision haute (2)Decision normale (2) Decision vrai (3) Decision faux PSfrag replacements σIM¯r(A,C)≥ 0.0315 miss value rate≥ 20 yes σIM¯r(A,C)≥ 0.0315 no miss value rate≥ 20 yes miss value rate≥ 20
¯ IMN(A, C)≤ 0.646 no ¯ IMN(A, C)≤ 0.646 yes ¯ IMN(A, C)≤ 0.646 no U N SET U N SET W IN S W IN S
Dans le premier chemin, nous avons deux valeurs manquantes {ensoleillé et haute}. La proba-bilité jointe P(ensoleillé, haute) est calculée de la manière suivante :
P(ensoleillé,haute) = P(haute) * P(ensoleillé|haute) (7.7) Parce que la valeur haute est moins dépendant de la classe que ensoleillé, la probabilité P(haute) est calculée à partir de l’AAOP de Humidité. Cet arbre contient un autre attribut manquant qui est Température. Température dépend également de Temps. Donc, la probabilité dans l’équa-tion 7.7 devient :
P(Temps = ensoleillé, Humidité = haute) = (7.8)
P(Température=élevée)*
P(Humidité=haute|Température=élevée)*
P(ensoleillé|Température = élevée,Humidité= haute)+ P(Température = moyenne)*
P(Humidité=haute|Température=moyenne)*
P(ensoleillé|Humidité = haute,Température = moyenne)+ P(Température = basse)*
P(Humidité = haute|Température=basse)*
P(ensoleillé|Humidité = haute,Température = basse)
Pour calculer la probabilité que Humidité est haute, nous devons calculer la probabilité que
Température est {élevée, moyenne ou basse}. La probabilité de Température est calculée de son
arbre AAOP donné dans la figure 7.373.
Nous remarquons que pour calculer les probabilités :
P(Température=élevée), P(Température = basse) and P(Température = moyenne) de l’équa-tion 7.8, nous appelons l’AAOP de Température 3 fois, correspondant aux trois valeurs possibles de l’attribut Température .
Dans l’AAOP de Température, nous parcourons seulement un chemin et cet arbre est formé d’un seul noeud-feuille. Donc, la complexité de parcours l’AAOP de Température est O(log1) = 0. Pour calculer la probabilité que Humidité est haute, nous appelons l’AAOP d’Humidité 3 fois parce que Température est inconnue. Donc, nous calculons la probabilité que Humidité est haute sachant que Température est élevée ; la probabilité que Humidité est haute sachant que
Tempé-rature est moyenne et la probabilité que Humidité est haute sachant que TempéTempé-rature est basse.
Dans ce cas, nous parcourons tous les chemins dans l’AAOP d’Humidité. Donc, la complexité de parcours tous les chemins dans l’AAOP d’Humidité est O(3log(3)).
Finalement, pour calculer la probabilité que Temps soit ensoleillé sachant que Humidité est
haute, nous devons calculer les trois probabilités suivantes : La probabilité que Temps soit enso-leillé sachant que Humidité est haute et Température est élevée ; La probabilité que Temps soit ensoleillé sachant que Humidité est haute et Température est moyenne ; La probabilité que Temps soit ensoleillé sachant que Humidité est haute et Température est basse. Donc, nous
73
7.3. Complexité de classement d’objet dans un arbre de décision
parcourons 3 chemins dans l’AAP de Temps en fonction des valeurs de Température avec la complexité O(3log(5)). La complexité totale est O(3log(3) + 3log(5)).
En conséquence, pour calculer la probabilité jointe dans l’équation 7.7, nous appelons l’AAP de Temps 3 fois, chacune pour un seul chemin ; nous appelons l’AAOP de Humidité 3 fois, à chaque fois l’arbre est appelé pour un seul chemin. De la même manière, nous appelons l’AAOP de Température 3 fois en fonction du nombre de ses valeurs.
En conséquence, nous avons appelé 9 arbres d’attributs ; la complexité de ces 9 arbres est la somme des complexités de chacun d’eux. En comparant avec l’équation 7.8, nous trouvons que :
– La complexité de parcours l’AAOP de Température pour la valeur élevée est O(0).74
– La complexité de parocurs l’AAOP de Température pour la valeur basseest O(0). – La complexité de parocurs l’AAOP de Température pour la valeur moyenneest O(0). – La complexité de parcours l’AAOP de Humidité pour la valeur haute sachant que
Tempé-rature est élevée est O(log(3)).
– La complexité de parcours l’AAOP de Humidité pour la valeur haute sachant que
Tempé-rature est moyenne est O(log(3)).
– La complexité de parcours l’AAOP de Humidité pour la valeur haute sachant que
Tempé-rature est basse est O(log(3)).
– La complexité de parcours l’AAP de Temps pour la valeur ensoleillé sachant que Humidité est haute etTempérature est élevé est O(log(3)).
– La complexité de parcours l’AAP de Temps pour la valeur ensoleillé sachant que Humidité est haute et Température est moyenne est O(log(3)).
– La complexité de parcours l’AAP de Temps pour la valeur ensoleillé sachant que Humidité est haute etTempérature est basse est O(log(3)).
Donc, la complexité totale devient : O(3log(3) + 3log(5)).
Nous pouvons calculer la complexité de notre algorithme de classement comme suit : Supposons qu’à la fin de notre processus du classement, nous ayons appelé nbAT arbres
d’attri-buts. La complexité de ces nbAT arbres est :
O(
i=nbAT
X
i=1
ComplexityT ree(T reei)) (7.9)
ComplexityT ree(T ree) = (
0 if one leaf/*LT ree = 1*/
O(log(LT ree)) else (7.10)
où LT ree est le nombre de feuilles de cet arbre.
Pour calculer nbAT, qui est le nombre d’arbres d’attributs appelés pendant le processus
du classement, nous supposons que l’instance à classer contient m attributs manquants et que l’attribut i prend vi valeurs. Dans le cas où tous ces attributs sont dépendants, nous pouvons calculer le nombre d’arbres d’attributs appelés pendant le processus de classement comme sui-vant : nbAT = m × (v1× v2× ... × vm)
où ¯v = v1+v2+...+vm
m est le nombre moyen des valeurs possibles pour chaque attribut. Le nombre des arbres appelés devient :
nbAT = m× ¯vm (7.11)
74
En conséquence, le nombre d’arbres d’attributs appelés est exponentiel en fonction du nombre d’attributs manquants dans l’instance à classer. À partir des équations 7.9, 7.10 et 7.11, nous pouvons calculer la complexité de tous les arbres appelés au cours du classement comme suit :
O(
i=nbAT
X
i=1
ComplexityT ree(T reei))
= O(
i=nbAT
X
i=1
log(LT reei))
= O(log(LT ree1) + log(LT ree2) + ... + log(LT reenbAT)) = O(log(LT ree1 × LT ree2× ... × LT reenbAT))
= O(log( i=nbAT Y i=1 LT reei)) = O(log( i=nbAT Y i=1 ¯ LT)) = O(log( ¯LnbATT )) = O(nbAT × log( ¯LT))
= O(m× ¯vmlog( ¯LT)) (7.12)
où :
– ¯LT est le nombre moyen des feuilles dans un arbre d’attribut. – m est le nombre d’attributs manquants dans l’instance.
– ¯v est le nombre moyen des valeurs pour chaque attribut manquant.
Nous remarquons que la complexité dans l’équation 7.12 augmente quand le nombre des valeurs manquantes augmentent.
Finalement, la complexité de classement d’une instance dans l’arbre de décision final en utilisant notre méthode est égale à la complexité de cet arbre de décision + les complexités de tous les arbres d’attributs appelés pendant le processus du classement75:
Complexity(T rees) = O(nbP athT ree Log(LT ree)) + O(
i=nbAT
X
i=1
ComplexityT ree(T reei))
(7.13) nbP athT ree= 1 if no missing values LT ree if all are missing nbP T else
(7.14)
Nous remarquons dans l’équation 7.13 que nbP athT reepeut être LT reedans le pire des cas quand tous les attributs sont manquants. Nous notons que la complexité O(nbP athT ree Logv(LT ree)) dans cette équation est quasi-linéaire en fonction du nombre de feuilles de l’arbre de décision final. En conséquence, la complexité totale de classement d’une instance avec valeurs manquantes devient :
Complexity(T rees) = O(nbP athT ree Log(LT ree)) + O(m× ¯vmlog( ¯LT))
75
Dans l’équation 7.14, LT reeest le nombre de feuilles dans cet arbre et est égal au nombre de tous les chemins. nbP T est le nombre de chemins que nous devons parcourir dans l’arbre de décision final.
7.4. Conclusion
Cette complexité est exponentielle en fonction du nombre d’attributs manquants dans l’instance à classer et quasi-linéaire en fonction du nombre de feuilles dans l’arbre de décision final.
7.3.2 Complexité de classement dans la méthode des Arbres d’Attribut