Scipy optimaliser Curve_Fit

Kartleggingsfunksjonen Curve_Fit () muliggjør fleksibilitet og tilbyr kontrollen å definere kurvetypen der optimaliseringsprosessen blir utført for å finne de visse optimaliserte funksjonsparametrene. Curve Fit () -metoden levert av Scipy vil bli dekket i denne artikkelen. Deretter, ved hjelp av eksempler, får vi se hvordan du bruker kurvet passform () -funksjonen.

Mot slutten av denne opplæringen vil vi oppdage hvordan du utfører kurvebeslaget i Python og hvordan kurveinnredning bruker de optimaliserte parametrene i en funksjon som kartlegger inngangseksemplene til output. Men først, la oss bli kjent med det grunnleggende om curve_fit ().

Python scipy optimaliser kurvepasningsfunksjon brukt for?

Python Scipy Optimize Curve Fit-funksjonen er mye brukt for å oppnå de best tilpassede parametrene. Curve_Fit () -funksjonen er en optimaliseringsfunksjon som brukes til å finne det optimaliserte parametersettet for en angitt funksjon som perfekt passer til det medfølgende datasettet.

Kurvepassfunksjonen () -funksjonen i Scipy er et open source-bibliotek, brukt til å passe kurver ved bruk av ikke-lineære minstekvadrater. Som et argument tar Curve_Fit () de samme inndataene, utdataene og kartleggingsfunksjonsnavnet som skal brukes. Kartleggingsfunksjonen skal godta inngangsdataprøver så vel som et sett med parametere.

I motsetning til overvåket læring, trenger Curve Fit -funksjonen deg for å definere funksjonene som perfekt kartlegger inngangene i utgangene. Kartleggingsfunksjonen kan ganske enkelt være en rett linje som lineær regresjon eller en buet linje som en polynomisk regresjon, eller det kan være noe annet.

Syntaks av Python Scipy.optimalisere.Curve_Fit ()

Scipy Curve Fit () syntaks er gitt nedenfor.

# Scipy.optimalisere.Curve_Fit (F, X-Data, Y-Data, Sigma = Ingen, P0 = Ingen)

Curve_Fit () tar noen nødvendige parametere og noen valgfrie parametere. 'F' er en modellfunksjon, f (a, ...). Det første argumentet det tar må være den uavhengige variabelen, og de gjenværende argumentene må være parametrene som passer.

'X-Data' -parameteren er en matrise-lignende parameter, som er en uavhengig variabel der dataene måles. 'Y-data' er en annen matrise-lignende parameter, som er en avhengig variabel også kjent som utgangen fra funksjonen.

'Sigma' er en valgfri parameter som bestemmer usikkerheten i 'Y-data'. Verdien av 'Sigma' kan være bare enkel 'ingen', 'm-lengde-sekvens eller' mxm array '. 'P0' -parameteren er en innledende gjetning for parametrene på N -lengde for parametrene. Det er en valgfri parameter, og hvis den ikke er gitt, vil startverdien være 1.

Curve_Fit () -funksjonen vil returnere de to verdiene; Popt og PCov. 'Popt' er en rekke som representerer de optimale verdiene for parametrene for å minimere summen av kvadratiske rester. Samtidig er 'PCOV' 2D -matrisen som representerer den estimerte samvariasjonen til 'Popt'.

Dessuten hever det de tre unntakene; Verdifeil, runtimefeil og optimalisering Advarsel. 'Verdifeil' blir kastet når enten X-Data eller Y-Data inneholder NANS, eller hvis noen inkompatibel metode blir brukt.

'Runtime -feilen' blir kastet når den minste firkantede minimeringen mislykkes. Og 'optimaliseringsvarsel' heves når samvariasjonen til parameteren ikke kan estimeres.

Eksempel 1:

I det første eksemplet vil vi tegne en rett linje som passer våre oppgitte data for å representere det lineære modelluttrykket. Etter å ha importert de nødvendige Python -bibliotekene, har vi brukt res2 = en*res1+to ligning for å lage et datasett på 30 poeng.

For å gjøre datasettet mer realistisk, har vi lagt til noe Gaussisk støy til RES2 -verdiene. Deretter brukte vi scipy.optimalisere.Kurvepasning () teknikk for å estimere verdiene til parametere 'One' og 'Two'. Her er den komplette programmeringskoden til modellen du kan følge.

Importer numpy som P
Importer matplotlib.Pyplot som MTB
Importer scipy
fra Scipy Import Optimize
def func (res1, en, to):
Returner en*res1 + to
res1 = s.Linspace (start = -40, stopp = 12, num = 30)
res2 = func (res1, 4, 2)
p.tilfeldig.frø (4)
støy = 10*P.tilfeldig.normal (størrelse = res2.størrelse)
res2 = res2 + støy
Popt, Cov = Scipy.optimalisere.Curve_Fit (Func, Res1, Res2)
en, to = popt
x_new_value = p.Arange (Min (Res1), 20, 5)
y_new_value = func (x_new_value, en, to)
MTB.spredning (res1, res2, color = "rød")
MTB.plot (x_new_value, y_new_value, color = "lilla")
MTB.xlabel ('x')
MTB.ylabel ('y')
print ("estimert verdi av en:"+ str (en))
print ("estimert verdi på to:" + str (to))
MTB.forestilling()

Nedenfor kan du finne resultatet av koden vedlagt ovenfor. De røde prikkene i den resulterende skjermen representerer datasettets virkelige datapunkter.

På den annen side er den lilla linjen kurven som er montert på datasettet ved å bruke scipy.optimalisere.Curve Fit () -metode. Dessuten gir det også den estimerte verdien av både parametere 'One' og 'Two', som også er beregnet av Scipy.optimalisere.Kurvepasning () teknikk.

Eksempel 2:

I det andre eksemplet vil vi forklare bruken av scipy.optimalisere.Curve_Fit () -metode for å plotte den eksponentielle kurven som passer våre data.

Her har vi brukt res2 = en*res2+en ligning for å lage et datasett med forskjellige punkter. Den gjenværende koden til programmet er den samme som eksemplet ovenfor. Her er koden for å plotte eksponentiell kurve med Curve_Fit () -funksjonen.

Importer numpy som P
Importer matplotlib.Pyplot som MTB
Importer scipy
fra Scipy Import Optimize
def func (res1, en, to):
Returner en*P.exp (to*res1)
res1 = s.Linspace (12, 20, 30)
res2 = func (res1, 0.4, 0.3)
Print (Res2)
støy = 100*P.tilfeldig.normal (størrelse = res2.størrelse)
res2 = res2 + støy
Print (Res2)
Popt, Cov = Scipy.optimalisere.Curve_Fit (Func, Res1, Res2)
en, to = popt
x_new_value = p.Arange (Min (Res1), Max (Res1), 1)
y_new_value = func (x_new_value, en, to)
MTB.spredning (res1, res2, color = ”grønn”)
MTB.plot (x_new_value, y_new_value, color = ”blå”)
MTB.xlabel ('x')
MTB.ylabel ('y')
Print (“Estimert verdi av en:“+ Str (en))
Print (“Estimert verdi på to:“ + Str (to))
MTB.forestilling()

La oss se utdataene.

Her kan du se den grafiske representasjonen.

Eksempel 3:

I det tredje eksemplet plotter vi de to kurvene samtidig rundt selve linjen for å se forskjellen mellom begge verdiene. Se koden nedenfor.

I koden har vi importert modulene og definert funksjonen (indikert som func_one). Etter det har vi satt verdiene og kalt Curve_Fit -funksjonen for å plotte disse verdiene på grafen.

Importer matplotlib.Pyplot som MTB
Importer numpy som P
Fra scipy.Optimaliser import curve_fit
def func_one (res1, en, to, tre):
Returner en * 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.tilfeldig.standard_rng ()
res2_noise = 0.2 * Rng.normal (størrelse = res1_data.størrelse)
res2_data = res2 + res2_noise
MTB.plot (res1_data, res2_data, 'b-', label = 'data')
POPT, PCOV = CURVE_FIT (FUNC_ONE, RES1_DATA, RES2_DATA)
Popt
MTB.plot (res1_data, func_one (res1_data, *popt), 'r-',
etikett = 'Fit: en =%5.3f, to =%5.3f, tre =%5.3f ' % tuple (POPT))
POPT, PCOV = Curve_FIT (Func_One, Res1_Data, Res2_Data, Bounds = (0, [3., 1., 0.5]))
Popt
MTB.plot (res1_data, func_one (res1_data, *popt), 'g--',
etikett = 'Fit: en =%5.3f, to =%5.3f, tre =%5.3f ' % tuple (POPT))
MTB.xlabel ('x')
MTB.ylabel ('y')
MTB.legende()
MTB.forestilling()

Utgangen er under der du kan se de resulterende kurvene.

Konklusjon

I denne artikkelen har vi gitt deg alle detaljene om bruken av Cuver_fit () -funksjonen levert av Scipy. Vi har startet med introduksjonen av Curve_Fit () -funksjonen, og så har vi lært syntaks for Curve_Fit () -funksjonen. Etter det har vi sett noen nyttige eksempler på hvordan Curve_Fit () -funksjonen brukes til å plotte linjene og kurvene i Python. Du kan kjøre disse eksemplene på egen hånd for å se output selv og en bedre generell forståelse av hele konseptet.