Recherche d’un expert de complexité minimale

Un autre sous-problème que nous allons rencontrer dans le cadre de notre algorithme est le suivant : étant donné un ensemble de point Sd, quelle est la fonction de ˆS_f de complexité minimale permettant de rendre compte de ces points ?

Nous allons donc écrire une routine getBestFit pour résoudre ce pro-blème. En plus de S_f et S_d, celle-ci prendra en argument deux entiers c_min et c_max permettant de spécifier respectivement une complexité minimale pour la solution que l’on cherche (qui vaudra par défaut Sf,min mais pourra prendre des valeurs plus élevées si l’on sait déjà qu’il n’y a pas de solution en-dessous La Généralisation de compétences robotiques 83

4.3. COCOTTE : algorithme et implémentation d’une certaine complexité) et une complexité maximale pour celle-ci (qui vau-dra par défaut S_f,maxmais pourra prendre des valeurs plus basses si l’on décide de rejeter les fonctions ayant une complexité plus élevée que celle du mélange d’experts qu’elles visent à remplacer). Après avoir déterminé la solution, get-BestFit renverra un couple (c, f), où f est la fonction de complexité minimale et où c est cette complexité minimale. Si aucune solution n’est trouvé, None sera renvoyé.

Une approche naïve consiste à parcourir les familles de fonctions de Sf par ordre croissant de complexité, et d’utiliser getFittingFunction pour dé-terminer si ces familles contiennent une fonction qui permet de rendre compte des points. Ceci est illustré en Pseudo-code 4.2.

Pseudo-code 4.2 Algorithme naïf pour la routine getBestFit function getBestFit(Sf, S_d, c_min = S_f,min, c_max = S_f,max)

sortByComplexity(Sf) for F ∈ Sf do f ← getFittingFunction(F , Sd) if f 6= None then c ← comp(F ) return (c, f) end if end for return None end function

On peut toutefois remarquer qu’au sein de notre ensemble Sf de familles de fonctions, certaines familles peuvent être incluses dans d’autres plus complexes. Par exemple, la famille des séries de Fourier de rang 3 ou moins de la première dimension de x est incluse dans celles des séries de Fourier de rang 4 ou moins de cette première dimension. Si une famille de fonctions ne suffit pas à rendre compte de S_d, on peut donc en déduire que toutes les familles incluses dans celle-ci sont également incapables de rendre compte de S_d.

Ceci nous permet donc d’adopter une approche plus efficace de recherche par dichotomie : pour explorer un intervalle entier de complexités possibles Jlow, highK, nous déterminerons un intervalle entier I = JrangeMin, rangeMaxK de petite taille et qui coupe _{Jlow, highK en sous-intervalles Jlow, rangeMinJ et} KrangeMax, highK de tailles similaires. Nous chercherons ensuite une fonction permettant de rendre compte de S_d au sein des familles de fonctions dont la complexité est dans I. Si de telles fonctions sont trouvées, on pourra éliminer l’ensemble_{KrangeMax, highK (qui ne contient que des fonctions plus complexes} que les solutions trouvées) et restreindre la recherche à_{Jlow, rangeMinJ. Dans} le cas contraire, on pourra à l’inverse éliminer _{Jlow, rangeMinJ et restreindre} la recherche à_{KrangeMax, highK, sous-réserve que I soit choisi de telle manière}

4. L’algorithme COCOTTE

que si aucune fonction de {f ∈ ˆS_f | comp(f) ∈ I} n’explique Sd, alors aucune fonction de ˆS_f de complexité inférieure ou égale à rangeMax non plus. Ceci est illustré en Figure4.4.

Figure 4.4 – On cherche un intervalle I = JrangeMin, rangeMaxK inclus dans Jlow, highK tel que si les fonctions dont la complexité est dans I n’expliquent pas Sd, alors aucune fonction dont la complexité est dans _{Jlow, rangeMinJ} n’explique S_dnon plus. Dans ce cas, on continue la recherche dans_KrangeMax, high_{K. À l’inverse, si des solutions sont trouvées, on continue la recherche dans} Jlow, rangeMinJ pour déterminer si d’autres solutions de complexité plus faible peuvent être trouvées.

Pour obtenir un intervalle I = _{JrangeMin, rangeMaxK vérifiant cette} pro-priété, on utilisera une routine complexityRangeMin(Sf, rangeMax) qui, étant donné une valeur de rangeMax, renvoie rangeMin comme la complexité minimale parmi les familles de fonctions de S_f qui ne sont incluses dans aucune autre et ont une complexité inférieure ou égale à rangeMax (elle renverra 0 s’il n’y en a aucune). Ceci est illustré en figure 4.5.

Figure 4.5 – Illustration de la routine complexityRangeMin(Sf, range-Max) lorsque rangeMax vaut 4 et que S_f contient 5 familles de fonctions de complexités respectives 1, 2, 3, 4 et 5 incluses les unes dans les autres, ainsi que 4 familles de fonctions de complexités respectives 1, 3, 5 et 7 également incluses les unes dans les autres. complexityRangeMin s’intéresse aux fa-milles de fonctions de S_f de complexité inférieure à rangeMax (on exclut donc les familles représentées ici en rouge) et parmi celles-ci uniquement à celles qui ne sont incluses dans aucune autre (on exclut donc les familles représentées ici en bleu). La routine renvoie alors la complexité minimale parmi les familles restantes (représentées ici en vert), c’est à dire 3.

4.3. COCOTTE : algorithme et implémentation Nous supposerons également que nous avons accès à une routine getFa-milies(Sf, c_min, c_max), qui renvoie la liste des (F , comp(F )), triée par com-plexité croissante, où les F sont les familles de Sf dont la complexité est comprise entre c_min et c_max inclus.

Un pseudo-code simplifié de getBestFit est donné en Pseudo-code 4.3, et une version plus détaillée est disponible annexe (Pseudo-codeA.1).

Pseudo-code 4.3 Algorithme de recherche dichotomique pour la routine get-BestFit

function getBestFit(Sf, S_d, c_min = S_f,min, c_max = S_f,max)

. ’low’ et ’high’ sont les bornes sur la complexité pour la recherche . dichotomique, et ’bestSol’ contient la solution à renvoyer

initialiser low, high, bestSol (avec low=c_min et high=c_max) while low ≤ high do

déterminer rangeMax, le milieu de [low, high]

en déduire rangeMin à l’aide de complexityRangeMin utiliser getFamilies pour obtenir la liste des familles

de fonctions de complexité dans [rangeMin, rangeMax]

utiliser getFittingFunction pour chercher la première solution dans cette liste

if solution trouvée then mettre à jour bestSol high ← rangeMin - 1 else low ← rangeMax + 1 end if end while return bestSol end function