Eu estou construindo um script que gera dados de entrada [parâmetros] para outro programa para calcular. Eu gostaria de otimizar os dados resultantes. Anteriormente, tenho usado a otimização de powell numpy. O código do psuedo se parece com algo assim.

def value(param):
     run_program(param)
     #Parse output
     return value

scipy.optimize.fmin_powell(value,param) 

Isso funciona muito bem; no entanto, é incrivelmente lento, pois cada iteração do programa pode levar dias para ser executada. O que eu gostaria de fazer é grãos grosseiros paralelizar isso. Portanto, em vez de executar uma única iteração por vez, ela seria executada (número de parâmetros) * 2 por vez. Por exemplo:

Initial guess: param=[1,2,3,4,5]

#Modify guess by plus minus another matrix that is changeable at each iteration
jump=[1,1,1,1,1]
#Modify each variable plus/minus jump.
for num,a in enumerate(param):
    new_param1=param[:]
    new_param1[num]=new_param1[num]+jump[num]
    run_program(new_param1)
    new_param2=param[:]
    new_param2[num]=new_param2[num]-jump[num]
    run_program(new_param2)

#Wait until all programs are complete -> Parse Output
Output=[[value,param],...]
#Create new guess
#Repeat

O número de variáveis ​​pode variar de 3 a 12, então algo como isso poderia acelerar o código de um ano para uma semana. Todas as variáveis ​​são dependentes umas das outras e eu estou apenas procurando por mínimos locais a partir do palpite inicial. Eu iniciei uma implementação usando matrizes hessianas; no entanto, isso é bastante complicado. Existe alguma coisa lá fora que faz isso, existe uma maneira mais simples, ou alguma sugestão para começar?

Portanto, a questão principal é a seguinte: Existe um algoritmo que adota uma estimativa inicial, gera vários palpites, usa esses vários palpites para criar um novo palpite e repete até que um limite seja encontrado. Apenas derivativos analíticos estão disponíveis. O que é uma boa maneira de fazer isso, existe algo já construído que faz isso, há outras opções?

Obrigado pelo seu tempo.

Como uma pequena atualização eu tenho este trabalho calculando parábolas simples através dos três pontos de cada dimensão e depois usando os mínimos como o próximo palpite. Isso parece funcionar decentemente, mas não é o ideal. Ainda estou procurando opções adicionais.

A melhor implementação atual é o paralelismo do loop interno do método de powell.

Obrigado a todos por seus comentários. Infelizmente, parece que simplesmente não há uma resposta concisa para esse problema específico. Se eu começar a implementar algo que faz isso, vou colá-lo aqui; no entanto, como o projeto não é particularmente importante ou a necessidade de resultados pressionando provavelmente eu ficarei satisfeito em deixar que ele ocupe um nó por algum tempo.