Scipy ottimizza Curve_fit
Entro la fine di questo tutorial, scopriremo come eseguire il raccordo della curva in Python e come il raccordo della curva utilizza i parametri ottimizzati in una funzione che mappa gli esempi di input per l'output. Ma prima, facciamo familiarità con le basi di Curve_fit ().
Python Scipy Ottimizza la funzione di adattamento della curva utilizzata per?
La funzione di adattamento della curva di ottimizzazione di Python Scipy è ampiamente utilizzata per ottenere i parametri più adatti. La funzione Curve_fit () è una funzione di ottimizzazione che viene utilizzata per trovare il set di parametri ottimizzato per una funzione dichiarata che si adatta perfettamente al set di dati fornito.
La funzione Curve Fit () in Scipy è una libreria open source, utilizzata per adattarsi alle curve usando i minimi quadrati non lineari. Come argomento, Curve_fit () prende gli stessi dati di input, i dati di output e il nome della funzione di mappatura che deve essere impiegato. La funzione di mappatura dovrebbe accettare campioni di dati di input e un set di parametri.
A differenza dell'apprendimento supervisionato, la funzione Curve Fit necessita di definire le funzioni che mappano perfettamente gli input negli output. La funzione di mappatura può essere semplicemente una linea retta come la regressione lineare o una linea curva come una regressione polinomiale, oppure potrebbe essere qualsiasi altra cosa.
Sintassi di Python Scipy.ottimizzare.curve_fit ()
La sintassi di Fit () Curve Fit () è fornita di seguito.
# Scipy.ottimizzare.Curve_fit (F, X-Data, Y-Data, Sigma = Nessuno, P0 = nessuno)Curve_fit () prende alcuni parametri richiesti e alcuni parametri opzionali. La "f" è una funzione modello, f (a, ...). Il primo argomento che prende deve essere la variabile indipendente e gli argomenti rimanenti devono essere i parametri per adattarsi.
Il parametro "X-Data" è un parametro simile a un array, che è una variabile indipendente in cui vengono misurati i dati. Il "data y" è un altro parametro simile a un array, che è una variabile dipendente nota anche come output della funzione.
Il "Sigma" è un parametro opzionale che determina l'incertezza in "Y-Data". Il valore di "Sigma" potrebbe essere semplicemente "Nessuno", sequenza M o "Array MXM". Il parametro "P0" è un'ipotesi iniziale di lunghezza N per i parametri. È un parametro opzionale e quindi, se non è fornito, il valore iniziale sarà 1.
La funzione Curve_fit () restituirà i due valori; Popt e PCOV. Il "popt" è un array che rappresenta i valori ottimali per i parametri per ridurre al minimo la somma dei residui quadrati. Allo stesso tempo, il "PCOV" è l'array 2D che rappresenta la covarianza stimata di "POPT".
Inoltre, aumenta le tre eccezioni; Errore del valore, errore di runtime e avviso di ottimizzazione. L'errore del valore viene lanciato quando i dati x o y contiene NANS o se viene utilizzato un metodo incompatibile.
L '"errore di runtime" viene lanciato quando la minimizzazione del minimo quadrata fallisce. E l'avvertimento di ottimizzazione "viene sollevato quando la covarianza del parametro non può essere stimata.
Esempio 1:
Nel primo esempio, trarremo una linea retta che si adatta ai nostri dati forniti per rappresentare l'espressione del modello lineare. Dopo aver importato le librerie Python richieste, abbiamo usato Res2 = One*Res1+Two Equation per creare un set di dati di 30 punti.
Per rendere il set di dati più realistico, abbiamo aggiunto un po 'di rumore gaussiano ai valori RES2. Quindi, abbiamo usato lo Scipy.ottimizzare.Tecnica Curve Fit () per stimare i valori dei parametri "uno" e "due". Ecco il codice di programmazione completo del modello che puoi seguire.
importa numpy come pImporta matplotlib.Pyplot come mtb
Import Scipy
da Scipy Import Optimize
def func (res1, uno, due):
restituire uno*res1 + due
Res1 = p.Linspace (start = -40, stop = 12, num = 30)
Res2 = func (res1, 4, 2)
P.casuale.Seme (4)
rumore = 10*p.casuale.normale (dimensione = res2.misurare)
res2 = res2 + rumore
Popt, cov = Scipy.ottimizzare.Curve_fit (Func, Res1, Res2)
uno, due = popt
X_NEW_VALUE = p.Arange (min (Res1), 20, 5)
y_new_value = func (x_new_value, uno, due)
mtb.SPIREST (Res1, Res2, Color = "Red")
mtb.Plot (x_new_value, y_new_value, color = "viola")
mtb.xlabel ('x')
mtb.ylabel ('y')
Print ("Valore stimato di uno:"+ STR (uno))
Print ("Valore stimato di due:" + STR (due))
mtb.spettacolo()
Di seguito, puoi trovare il risultato del codice sopra legato. I punti rossi nella schermata risultante rappresentano i punti dati reali del set di dati.
D'altra parte, la linea viola è la curva montata sul set di dati utilizzando il Scipy.ottimizzare.Metodo Curve Fit (). Inoltre, fornisce anche il valore stimato di entrambi i parametri "uno" e "due", che è anche calcolato da Scipy.ottimizzare.Tecnica Curve Fit ().
Esempio 2:
Nel secondo esempio, spiegheremo l'uso dello Scipy.ottimizzare.Metodo Curve_fit () per tracciare la curva esponenziale che si adatta ai nostri dati.
Qui, abbiamo usato Res2 = One*Res2+One Equation per creare un set di dati di punti diversi. Il codice rimanente del programma è lo stesso dell'esempio sopra. Ecco il codice per tracciare la curva esponenziale con la funzione curve_fit ().
Importa numpy come pImporta matplotlib.Pyplot come mtb
Import Scipy
da Scipy Import Optimize
def func (res1, uno, due):
restituire uno*p.exp (due*res1)
Res1 = p.Linspace (12, 20, 30)
Res2 = func (res1, 0.4, 0.3)
Stampa (Res2)
rumore = 100*p.casuale.normale (dimensione = res2.misurare)
res2 = res2 + rumore
Stampa (Res2)
Popt, cov = Scipy.ottimizzare.Curve_fit (Func, Res1, Res2)
uno, due = popt
X_NEW_VALUE = p.Arange (min (Res1), Max (Res1), 1)
y_new_value = func (x_new_value, uno, due)
mtb.SPIREST (Res1, Res2, Color = "Green")
mtb.trama (x_new_value, y_new_value, color = "blu")
mtb.xlabel ('x')
mtb.ylabel ('y')
Stampa ("Valore stimato di uno:"+ STR (uno))
Stampa ("Valore stimato di due:" + STR (due))
mtb.spettacolo()
Vediamo l'output.
Qui, puoi vedere la rappresentazione grafica.
Esempio 3:
Nel terzo esempio, tracciamo contemporaneamente le due curve attorno alla linea effettiva per vedere la differenza tra i due valori. Vedi il codice qui sotto.
Nel codice, abbiamo importato i moduli e definito la funzione (indicata come func_one). Successivamente, abbiamo impostato i valori e chiamato la funzione Curve_fit per tracciare quei valori sul grafico.
Importa matplotlib.Pyplot come mtbimporta numpy come p
da Scipy.Ottimizza l'importazione Curve_Fit
def func_one (res1, uno, due, tre):
restituire uno * p.exp (-two * res1) + tre
res1_data = p.Linspace (0, 2, 40)
Res2 = func_one (res1_data, 1.5, 1.2, 0.6)
rng = p.casuale.default_rng ()
res2_noise = 0.2 * rng.normale (size = res1_data.misurare)
res2_data = res2 + res2_noise
mtb.Plot (res1_data, res2_data, 'b-', etichetta = 'data')
popt, pcov = curve_fit (func_one, res1_data, res2_data)
popt
mtb.Plot (res1_data, func_one (res1_data, *popt), 'r-',
etichetta = 'fit: one =%5.3f, due =%5.3f, tre =%5.3f ' % tuple (popt))
popt, pcov = curve_fit (func_one, res1_data, res2_data, limite = (0, [3., 1., 0.5]))
popt
mtb.Plot (res1_data, func_one (res1_data, *popt), 'g--',
etichetta = 'fit: one =%5.3f, due =%5.3f, tre =%5.3f ' % tuple (popt))
mtb.xlabel ('x')
mtb.ylabel ('y')
mtb.leggenda()
mtb.spettacolo()
L'output è sotto dove è possibile vedere le curve risultanti.
Conclusione
In questo articolo, ti abbiamo fornito tutti i dettagli sull'uso della funzione Cuver_fit () fornita da Scipy. Abbiamo iniziato con l'introduzione della funzione curve_fit () e quindi abbiamo imparato la sintassi della funzione Curve_fit (). Successivamente, abbiamo visto alcuni esempi utili di come la funzione Curve_fit () viene utilizzata per tracciare le linee e le curve in Python. Puoi eseguire questi esempi da solo per vedere l'output da solo e una migliore comprensione generale dell'intero concetto.