Scipy ottimizza la radice

Python è un linguaggio di computer orientato agli oggetti, strutturato e funzionale. La sua applicazione non è limitata a tipi specifici che lo rendono un linguaggio per scopi generali. È un linguaggio di programmazione ben familiare e offre una varietà di librerie per scrivere i diversi programmi software in questo linguaggio. La sceneggiatura di questa lingua è anche simile alla lingua inglese. In virtù di questo fatto, Python ha il merito di essere un linguaggio di programmazione per principianti per applicazioni come il calcolo scientifico e tecnico, l'integrazione, l'elaborazione del segnale e delle immagini e l'interpolazione della Biblioteca Python che è "Scipy", che si occupa di tutti tali funzioni specifiche.

Scipy ha un attributo della funzione denominata "ottimizza. radice ()". Questa funzione contiene gli ottimizzatori. Gli ottimisti rappresentano l'insieme di tali funzioni o le procedure che riducono il valore/output finale della funzione o la radice di tale funzione al più piccolo valore possibile.

Procedura:

La procedura di questo articolo segue alcuni passaggi importanti. Prima di tutto, impareremo sull'ottimizzazione. root () "funzione. Quindi, sapremo a sapere quali moduli dal Scipy sono tenuti a lavorare con questa funzione. Impareremo anche sulla sintassi di ottimizzare.funzione root () nello script Python. Quindi, faremo alcuni esempi per mettere le mani con questo argomento.

Sintassi:

Di seguito è riportata la sintassi e il metodo di dichiarazione per la chiamata di ottimizzare.Funzione radice nel programma Python:

$ SCIPY.ottimizzare.root (divertimento, x0, args = (), metodo = 'hybr', jac = nessuno, tol = none, callback = nessuno, options = nessuno)

La prima funzione dei parametri nell'elenco degli argomenti di input di questa funzione è il "divertimento". Questa è l'equazione o la funzione su cui vogliamo applicare "ottimizza. root () “funzione. Il prossimo è "x0" che è un ospite iniziale da calcolare per le radici. Gli "args" sono il parametro aggiuntivo che possiamo aggiungere all'obiettivo della funzione. E il "metodo" è un parametro importante che definisce il tipo di risolutore della funzione ottimizzatore. "Jac" significa giacobino. Se il suo valore è specificato sul valore "vero", la funzione restituisce il valore del giacobino con la funzione di obiezione. In un caso alternativo, il giacobino viene calcolato numericamente ed è un altro parametro opzionale. Quindi la "TOL" è la tolleranza per l'arresto della funzione e dipende dal tipo di solutore; Ancora una volta, un parametro opzionale.

Valore di ritorno:

La funzione restituisce l'oggetto del tipo di risultato ottimizzato nell'output che ha l'array che rappresenta la soluzione. Il messaggio di successo è una bandiera booleana, il che significa che la funzione è uscita dal successo e la causa del messaggio di terminazione.

Esempio 1:

Il "ottimizza.La funzione root () "ottimizza la funzione e riduce o aumenta il valore secondo il requisito nel programma. Trova anche le radici per una funzione che può essere sotto forma di un'equazione non lineare.

Con la sintassi precedente che dobbiamo imparare, facciamo un esempio molto semplice per questo ottimizzare.root () funzionare e trovare le radici per un'equazione o funzione non lineare. La piattaforma che useremo per utilizzare il compilatore Python è "Google Collab". Questo è un programma open source e fornisce tutti i pacchetti già installati e scaricati. Per iniziare con il nuovo programma, allocare un nuovo notebook in Google Drive nella collaborazione.

Dopo aver creato con successo un notebook, integriamo i pacchetti Python richiesti nel programma. Per questo, integreremo lo Scipy. Poiché l'attributo di Scipy Optimize ha il modulo "root", dobbiamo importare la radice dallo "Scipy.Ottimizzare". Dal momento che abbiamo già discusso che l'ottimizzazione.root () prende il "func" nell'elenco degli argomenti di input e il func è semplicemente una forma dell'equazione non lineare, integriamo la libreria "matematica" per scrivere queste equazioni non lineari con il modulo richiesto nella funzione equazione. L'equazione per la funzione di questo esempio è la seguente:

a + sin (a)

L'equazione data ha la funzione trigonometrica che è "peccato". Integriamo la biblioteca matematica come "peccato". Con questa importazione dei pacchetti Python richiesti, ora definiamo l'equazione nella funzione. Per questa attività, creiamo una funzione con il nome "func" e il tipo di ritorno "def". Passiamo la variabile "A" all'argomento della funzione. Quindi, facciamo la funzione restituire l'equazione come "return x + sin (x)".

Ora, chiamiamo questa funzione per utilizzare questa equazione nel metodo "root ()" come argomento di input. Chiama la funzione "root ()" e passa il nome della funzione per la quale definiamo l'equazione come "func" insieme al valore di ipotesi iniziale uguale a "0" per le radici. Ora visualizza i risultati con il metodo Print (). Il programma per questa funzione con il suo output è mostrato nel seguente frammento:

da Scipy.ottimizzare la radice di importazione
dal peccato di importazione matematica
def func (a):
restituire un + sin (a)
value = root (func, 0)
Stampa (valore)

La funzione ha restituito l'array di soluzione come radice dell'equazione. La soluzione si è convergiata.

Esempio 2:

Con lo stesso metodo che abbiamo appreso nel primo esempio, possiamo aggiungere la funzione "JAC" con l'equazione e applicare "ottimizza.root () "funzione su di essa per ottenere il valore minimo per la funzione. Importa il "Scipy.ottimizzare "come" root "e" numpy "come" np ". Dichiarare la funzione "func" e restituire l'equazione in essa come "[a [0] + 0.4*(a [0] - a [1]) ** 2 - 1.0, 0.4*(a [1] - a [0]) ** 2 + a [1]] ". Definire un'altra funzione, "giacobino", che è il parametro aggiuntivo e restituire l'equazione in essa come "[1 + 1.4*(a [0] - a [1]) ** 2, -1.4*(a [0] - a [1]) ** 2], [-1.4*(A [1] - A [0]) ** 2, 1 + 1.4*(a [1] - a [0]) ** 2]] ". Passa il "func", ipotesi iniziale "x0", il "giacobino" e il "solutore /metodo" come "hyb" alla funzione "root ()" ed esegui il programma come segue:

Importa Numpy come NP
da Scipy.ottimizzare la radice di importazione
def func (a):
restituire [a [0] + 0.4*(a [0] - a [1]) ** 2 - 1.0,
0.4*(A [1] - A [0]) ** 2 + A [1]]
Def Jacobian (A):
restituire np.array ([[1 + 1.4*(a [0] - a [1]) ** 2, -1.4*(a [0] - a [1]) ** 2], [-1.4*(A [1] - A [0]) ** 2, 1 + 1.4*(a [1] - a [0]) ** 2]])
value = root (func, [0, 0], jac = jacobian, method = 'hybr')
Stampa (valore)

La funzione ha restituito le radici ottimizzate come array di soluzione con gli altri due parametri.

Conclusione

La operazione e l'implementazione dell'ottimizzazione di "Scipy.La funzione root () "è mostrata in questo articolo. Abbiamo eseguito la funzione root () su due esempi separati e con parametri di funzione diversi.