Je résous un problème de "mélange" d'ensembles d'images qui se chevauchent. Ces ensembles peuvent être représentés par un graphique pondéré non orienté tel que celui-ci:
Chaque nœud représente une image. Les images qui se chevauchent sont reliées par un bord. Le poids des bords représente la taille de la zone de chevauchement (le fait de mélanger plus tôt un chevauchement plus élevé entraîne une meilleure qualité globale ).
L'algorithme supprime généralement les bords. Il peut le faire séquentiellement ou en parallèle. Cependant, lors de la fusion, les nœuds fusionnent et la structure du graphique change. La parallélisation n'est donc possible que sur des composants connectés qui ne se chevauchent pas!
Ces composants qui ne se chevauchent pas sont DB et FEG. Nous pouvons exécuter l'algorithme de fusion sur ces composants en toute sécurité en parallèle. Le résultat est le graphique suivant (les nœuds fusionnés sont affichés en vert):
Désormais, il n'y a plus de parallélisation possible car deux composants connectés se chevauchent (ils ont un bord directement entre eux).
La version parallèle de l'algorithme ressemblerait à ceci:
1. Find connected components (no two are connected directly) and create task for each.
2. Run the tasks in parallel.
3. Update graph.
4. Until single node remains, continue with 1.
La partie délicate est la première étape: comment trouver le meilleur ensemble de composants connectés?
Une façon serait un algorithme gourmand qui trouve simplement le plus grand nombre de composants à une itération donnée. L'algorithme gourmand maximisera la parallélisation au début mais au prix de nombreuses itérations plus tard.
La solution optimale peut être d'apporter une bonne quantité de composants connectés à chaque itération pour maximiser la parallélisation et minimiser le nombre d'itérations en même temps (il y a donc deux variables dans l'optimisation).
Je ne peux penser à aucun algorithme d'optimisation autre que le backtracking, c'est-à-dire rechercher l'espace de toutes les évolutions possibles et choisir celui avec une parallélisation maximale.
Les poids des bords peuvent être ignorés, mais une version améliorée de l'algorithme peut en tenir compte, car les zones plus grandes prennent plus de temps à se mélanger (par exemple, une zone de taille 200 prendra environ deux fois plus de temps à fusionner que deux zones de taille 100). La prise en compte des poids peut conduire à une meilleure stratégie de sélection des composants (temps d'exécution global plus rapide de l'algorithme).
Avez-vous des indices pour un tel algorithme d'optimisation, qui trouve la meilleure stratégie de sélection de parties de graphique afin qu'il y ait une parallélisation maximale et un nombre minimum d'itérations?