Parallèle d'optimisation dimensionnelle

Je pense que ce que vous voulez faire est d'utiliser les capacités de threading Python intégrées. Fourni que votre fonction de travail a plus ou moins le même temps d'exécution quels que soient les paramètres, ce serait efficace.

Créez 8 threads dans une piscine, exécutez 8 instances de votre fonction, obtenez 8 résultats, exécutez votre optimisation Algo pour modifier les paramètres avec 8 résultats, répéter .... Bénéfice?

Si je n'ai pas eu de mal ce que vous demandez, vous essayez de minimiser votre fonction un paramètre à l'heure.

Vous pouvez l'obtenir en créant un ensemble de fonctions d'un seul argument, où pour chaque fonction Vous gelez tous les arguments sauf un.

Ensuite, vous optimisez une boucle optimisant chaque variable et mettez à jour la solution partielle.

Cette méthode peut accélérer de nombreuses fonctions de plusieurs paramètres où le paysage énergétique n'est pas trop complexe (la dépendance entre les paramètres n'est pas trop forte).

donné une fonction xxx

Vous créez la supposition et la fonction: xxx

que vous les mettez dans un certain cycle de l'optimisation xxx

c'est un très simple mais Méthode efficace de simplification de votre tâche de minimisation. Je ne me souviens pas vraiment de savoir comment cette méthode est appelée, mais un look proche de l'entrée de Wikipedia sur la minimisation devrait faire l'affaire.

sont des dérivés de votre fonction d'objectif disponible? Si oui, vous pouvez utiliser descente de gradient (ancienne, lente mais fiable) ou Gradient de conjugué . Sinon, vous pouvez approximer les dérivés en utilisant des différences finies et utilisez toujours ces méthodes. Je pense en général, si vous utilisez des approximations de différentielles finies aux dérivés, vous êtes beaucoup mieux à utiliser les gradients de conjugué plutôt que sur la méthode de Newton.

Une méthode plus moderne est SPSA qui est une méthode stochastique et ne nécessite pas de dérivés. SPSA nécessite beaucoup moins d'évaluations de la fonction d'objectif pour le même taux de convergence que la différentialité de différentielle finie aux gradients conjugués, pour des problèmes quelque peu bien élevés.

Il existe deux façons d'estimer des gradients, un facilement parallélizable, une non:

• autour d'un point unique, par exemple (F (direction X + H _{i ) - F (x)) / h; Ceci est facilement parallélizable à NDIM}
• dégradé "marche": marcher de x 0 dans la direction E 0 to x 1 , puis à partir de x 1 dans la direction E 1 à x 2 ...; Ceci est séquentiel.

  Les minimiseurs utilisant des gradients sont très développés, puissants, convergent quadratique (sur des fonctions suffisamment lisses). La fonction de gradient fournie par l'utilisateur peut bien sûr être un estimateur de gradient parallèle.
  Quelques minimiseurs utilisent des gradients de "marche", parmi les méthodes de Powell, Voir Recettes numériques p. 509.
  Donc, je suis confus: comment parallèle sa boucle intérieure?

  Je suggérerais scipy fmin_tnc Avec un estimateur de gradient parallèle, peut-être utiliser des différences centrales et non unilatérales.
  (Fwiw, Ce compare certains des optimiseurs scipy non dérivés sur deux fonctions 10-D; ymmv.)

J'ai eu le même problème alors que j'étais à l'université, nous avions un algorithme de Fortran pour calculer l'efficacité d'un moteur basé sur un groupe de variables. Au moment où nous utilisons modefrontier et si je me souviens bien, aucun des algorithmes n'a été capable de générer plusieurs suppositions.

L'approche normale serait d'avoir une DOE et là où certains algorithmes pour générer la DOE au mieux adapté à votre problème. Après cela, nous allions exécuter les entrées de biche unique parallèles et un algorithme «surveillerait» le développement des optimisations indiquant le meilleur design actuel.

Note latérale: Si vous n'avez pas de grappe et si vous avez besoin de plus de puissance informatique, HTCondor peut vous aider.

Vous pouvez faire parallèlement à deux parties: 1) parallèlement le calcul de l'itération unique ou 2) Démarrage parallèle N Devoir initial.

On 2) Vous avez besoin d'un contrôleur de travail pour contrôler les n threads de découverte initiales.

Veuillez ajouter une sortie supplémentaire sur votre programme: "Bibliothèque inférieure" qui indique que les valeurs de sortie des décents du paramètre d'entrée actuel ne sont pas inférieures à cette limite inférieure.

Le nouveau thread de devinette initial peut concurrencer les uns avec les autres; Si la limite inférieure d'un fil d'un thread est supérieure à la valeur actuelle du thread existant, ce filetage peut être supprimé par votre contrôleur de travail.

La parallélisation des optimiseurs locaux est intrinsèquement limitée: ils commencent à partir d'un seul point initial et tentent de travailler en descente, des points plus tard dépendent des valeurs des évaluations précédentes. Néanmoins, il y a quelques avenues où une quantité modeste de parallélisation peut être ajoutée.

• Comme autre réponse indique, si vous devez évaluer votre dérivé à l'aide d'une méthode de différence finie, de préférence avec une taille d'étape adaptative, cela peut nécessiter de nombreuses évaluations de fonction, mais le dérivé par rapport à chaque variable peut être indépendant; Vous pourriez peut-être obtenir une vitesse d'accélération d'un facteur de deux fois le nombre de dimensions de votre problème. Si vous avez plus de processeurs que vous savez quoi faire avec, vous pouvez utiliser des formules de gradient précises à des commandes supérieures nécessitant des évaluations plus (parallèles).
• Certains algorithmes, à certaines étapes, utilisent des différences finies pour estimer la matrice de Hesse; Cela nécessite environ la moitié du carré du nombre de dimensions de votre matrice, et tout peut être fait en parallèle.

  Certains algorithmes peuvent également être en mesure d'utiliser plus de parallélisme à un coût algorithmique modeste. Par exemple, les méthodes quasi-Newton tentent de construire une approximation de la matrice Hesse, à la mise à jour souvent en évaluant un gradient. Ils font ensuite une étape vers le minimum et évaluent un nouveau gradient pour mettre à jour l'Hesse. Si vous avez suffisamment de processeurs afin que l'évaluation d'un Hesse soit aussi rapide que d'évaluer la fonction une fois, vous pouvez probablement les améliorer en évaluant l'HESSIAN à chaque étape.

  aussi loin que les implémentations vont, je crains que vous n'ayez un peu de chance. Il existe un certain nombre d'implémentations intelligentes et / ou bien testées, mais elles sont toutes, autant que je sache, un seul fileté. Votre meilleur pari est d'utiliser un algorithme qui nécessite un gradient et calculez votre propre en parallèle. Ce n'est pas si difficile d'écrire un adaptatif qui fonctionne en parallèle et choisit des tailles d'étape raisonnables pour ses dérivés numériques.