Scipy.optimize: come limitare i valori degli argomenti

Question

Sto tentando di utilizzare le funzioni scipy.optimize per trovare un minimo globale di una funzione complicata con diversi argomenti. scipy.optimize.minimize sembra fare il lavoro meglio di tutti, vale a dire il metodo "Nelder-Mead". Tuttavia, tende ad andare nelle aree fuori dal dominio degli argomenti (per assegnare valori negativi agli argomenti che possono essere solo positivi) e restituisce quindi un errore in questi casi. C'è un modo per limitare i limiti degli argomenti all'interno della funzione? O forse all'interno di altre funzioni scipy.optimize?

ho trovato i seguenti consigli:

Quando i parametri cadono fuori del campo ammissibile, restituire un numero enorme selvaggiamente (lontano dai dati da montare). Questo (si spera) penalizzerà questa scelta di parametri così tanto che curve_fit si stabilirà su un altro set di parametri ammissibile come ottimale.

given in this previous answer, ma nel mio caso la procedura richiederà molto tempo computazionale.

Answer 1

Il Nelder-Mead risolutore non supporta l'ottimizzazione vincolata, ma ci sono molti altri che lo fanno.

TNC e L-BFGS-B supportano entrambi solo vincoli vincolati (ad esempio x[0] >= 0), che dovrebbero essere adatti al caso. COBYLA e SLSQP sono più flessibili, supportando qualsiasi combinazione di limiti, uguaglianza e vincoli basati sulla disuguaglianza.

È possibile trovare informazioni più dettagliate sui risolutori osservando i documenti per le funzioni autonome, ad es. scipy.optimize.fmin_slsqp per method='SLSQP'.

È possibile vedere la mia risposta precedente here per un esempio di ottimizzazione vincolata utilizzando SLSQP.

Answer 2

La funzione minimize ha un bounds parameter che può essere utilizzato per limitare i limiti per ciascuna variabile quando si utilizzano i metodi L-BFGS-B, TNC, COBYLA o SLSQP.

Per esempio,

import scipy.optimize as optimize 

fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2 
res = optimize.minimize(fun, (2, 0), method='TNC', tol=1e-10) 
print(res.x) 
# [ 1.   2.49999999] 

bnds = ((0.25, 0.75), (0, 2.0)) 
res = optimize.minimize(fun, (2, 0), method='TNC', bounds=bnds, tol=1e-10) 
print(res.x) 
# [ 0.75 2. ] 

Answer 3

So che questo è in ritardo nel gioco, ma forse dare un'occhiata a mystic. È possibile applicare le funzioni arbitrarie di Python come funzioni di penalità, o applicare vincoli di limiti e altro ... su qualsiasi ottimizzatore (compreso l'algoritmo da scipy.optimize.fmin).

https://github.com/uqfoundation/mystic

Answer 4

L'argomento che stai cercando è: constraints che è uno degli argomenti passati al . Stendete la propria funzione lambda che riceve i parametri per limitare in questo modo:

#A function to define the space where scipy.minimize should 
#confine its search: 
def apply_sum_constraint(inputs): 
    #return value must come back as 0 to be accepted 
    #if return value is anything other than 0 it's rejected 
    #as not a valid answer. 
    total = 50.0 - np.sum(inputs) 
    return total 

my_constraints = ({'type': 'eq', "fun": apply_sum_constraint }) 
result = spo.minimize(f, 
         guess, 
         method='SLSQP', 
         args=(a, b, c), 
         bounds=((-1.0, 1.0), (-1.0, 1.0)), 
         options={'disp': True}, 
         constraints=my_constraints) 

L'esempio di cui sopra afferma che tutti i nuovi candidati in prossimità di l'ultimo elemento cercato meglio aggiungere fino a 50. Cambio che il metodo per definire il lo spazio di ricerca ammissibile e la funzione scipy.minimize non sprecheranno energia considerando quelle risposte.