Scipy Interpolate

Interpolasjon er det vi skal diskutere i dag. Interpolasjonsbegrepet kan defineres som en metode for å beregne en verdi eller antall mellom to punkter på en linje eller til og med en kurve. Dette konseptet kan bruke dataene i 1, 2 eller enda høyere dimensjoner siden det er flere generelle muligheter tilgjengelig i scipy for interpolasjon så vel som glatthet. Enten dataene er ustrukturert, endimensjonal eller gitt på et strukturert rutenett, bestemmer de hvilken interpolasjonsmetode som brukes. Interpolatorens nødvendige glatthet er en annen vurdering. Metodene som er foreslått for interpolasjon kommer i en rekke former. Med tilstrekkelig forklaring og eksempler, vil vi diskutere om Scipys interpolasjon i denne artikkelen.

Interpolasjon i scipy

Scipy tilbyr en modul som heter Scipy.Interpolat som har et bredt spekter av interpolasjonsrelaterte funksjoner. En metode for å lage datapunktene mellom eksisterende datapunkter kalles interpolasjon. Det er klasser, splinefunksjoner og univariate og multivariate interpolasjonsklasser i Scipy -modulen, Scipy.Interpolat.

Interpolasjonstyper

Det er mange måter å interpolere på, hvorav noen inkluderer:

• • 1-D interpolasjon
  • Spline interpolasjon
  • Univariat spline interpolasjon
  • RBF -interpolasjon

La oss diskutere alle disse typene i detalj og med programmeringseksempler for å se resultatene.

1-D interpolasjon

En distribusjon med bare en variabel kan interpoleres ved bruk av interp1d () -funksjonen. Det krever innspill fra to punkter, x og y, og gir ut en kallbar funksjon som, når den kalles med en ny x, returnerer passende y.

Her er den fullstendige syntaksen:

La oss forklare konseptet med 1-D-interpolasjon med følgende eksempel:

Eksempel:

La oss si at du vil bruke X_Range- og Y_Range -verdiene for å bygge en lineær funksjon med Y_Range = F (X_Range) formelen.

Dette eksemplet viser hvordan du lager en funksjon som allerede bruker to velkjente X_Range- og Y_Range-variabler for å estimere datapunktene på en linje ved hjelp av scipy.Interpolat.Interp1D () -metode. Begrepet "interp1d" refererer til interpolasjon på en enkelt dimensjon, for eksempel en linje, ved å bruke bare x_range og y_range -aksene. Hele koden er gitt her.

Den første delen av koden viser at vi importerer de nødvendige modulene. Dette er matplotlib.pyplot, numpy, scipy og interp1d. Den neste delen viser generering av de tilfeldige punktene for X_Range og Y_Range og bruken av disse to verdiene, X_Range og Y_Range. Det inkluderer også utførelsen av scipy.Interpolat.Interp1d () -metode der X_Range- og Y_Range -verdiene sendes som parametere. Etter det genereres nye tilfeldige poeng for X_Range og Y_Range. De fire utskriftsuttalelsene som brukes her viser punktene generert av den lineære funksjonen.

Den siste delen av koden er der en graf er plottet ved hjelp av x_range, y_range og de resulterende x_res og y_res verdier.

Importer matplotlib.Pyplot som Plt
Importer numpy
Importer scipy
Fra scipy.Interpolate import interp1d
x_range = numpy.Arange (12,20)
trykk ('x:', x_range)
y_range = numpy.exp (-x_range/10)
trykk ('y:', y_range)
func_linear = scipy.Interpolat.Interp1d (X_Range, Y_Range)
x_res = numpy.Arange (12,19,0.1)
y_res = func_linear (x_res)
print ('new_x:', x_res)
trykk ('new_y:', y_res)
plt.spredning (x_range, y_range, color = 'rød')
plt.plot (x_res, y_res, farge = 'oransje')
plt.xlabel ("x")
plt.ylabel ("y")
plt.tittel ("1-D interpolasjon")
plt.forestilling()
plt.SaveFig ('Resultat/graf.png ')

Dette er den resulterende skjermen der du kan se implementeringen av 1-D-interpolasjonen på skjermen:

Spline interpolasjon

Dette eksemplet handler om spline -interpolasjonen.

I datatekniske felt for datastyrt modellering og datagrafikk, blir en piecwise polynomial (parametrisk) krumning oftere referert til som en spline. På grunn av deres enkelhet i konstruksjon, enkelhet og nøyaktighet i evaluering, og kapasitet til å forutsi komplekse former gjennom kurvemontering og svært interaktiv kurvdesign, blir splines ofte brukt i en rekke felt.

Spline-interpolasjon bruker polynomer-observerte splines for å bygge en stykkevis funksjon, i motsetning til 1D-interpolasjon, der punkter er montert for en enkelt kurve.

UnivariatesSpline () -metoden aksepterer to parametere, XS og YS, og genererer en kallbar funksjon som kan påberopes med en ny verdi for XS. Se følgende vedlagte kode:

Koden ligner veldig på det forrige eksemplet, bortsett fra at vi bruker de forskjellige inngangsverdiene her. Deretter interpolerte.splev () -funksjonen brukes på disse verdiene. Ulike verdier genereres for x, y og t. Disse verdiene er plottet på skjermen med en kodelinje i den siste delen av det vedlagte bildet:

Importer numpy
Importer matplotlib.Pyplot som Plt
fra scipy import interpolat
x = numpy.Arange (0, 12)
y = numpy.cos (x ** 3)
t = interpolat.splrep (x, y, s = 0)
x = numpy.Arange (0, numpy.pi ** 2, numpy.pi/100)
y = interpolat.SPLEV (X, T, DER = 0)
plt.figur()
plt.plot (x, y, '*', x, y, x, numpy.cos (x),
x, y, 'b', farge = "rød")
plt.Legend (['Lineær', 'Cubic Spline', 'True'])
plt.Axis ([-0.2, 5.6, -1.3, 1.2])
plt.Tittel ('Cubic-Spline Interpolation Eksempel')
plt.forestilling()

Følgende er den genererte grafen som forklarer konseptet med kubisk-spline-interpolasjon:

Univariat spline interpolasjon

Vi snakker om den univariate spline her. Det passer til et spesifikt sett med datapunkter og er en 1-D glattende spline. Inngangsdataene X Val og Y val er montert på en spline av K -grad ved hjelp av scipy.Interpolat.Univariatespline. Scipy.Interpolat.Univariatespline -metoden har enda et argument, som setter antall knuter ved å spesifisere en utjevningstilstand. Spline.Angi utjevningsfaktor () -funksjon beregner spline ved å bruke den spesifiserte utjevningsfaktoren og knutene identifisert av forrige samtale.

Importer numpy
Importer matplotlib.Pyplot som Plt
Fra scipy.Interpolere import univariatespline
x_val = numpy.Linspace (-3, 3, 40)
y_val = numpy.EXP (-X_VAL ** 2) + 0.1 * Numpy.tilfeldig.Randn (40)
plt.Tittel ("Univariate Spline")
plt.plot (x_val, y_val, 'g.', MS = 8)
spline_shape = univariatespline (x_val, y_val)
xs_shape = numpy.Linspace (-3, 3, 2000)
plt.Plot (XS_Shape, Spline_Shape (XS_Shape), 'Yellow', LW = 3)
spline_shape.set_smoothing_factor (0.5)
plt.Plot (XS_Shape, Spline_Shape (XS_Shape), Color = 'Orange', LW = 3)
plt.forestilling()

Følgende er den genererte grafen over den forrige koden:

Radial basisfunksjon (RBF) interpolasjon

I dette siste eksemplet vil vi fokusere på den radielle basisfunksjonen (RBF) for interpolasjon. Interpolat Scipy.RBF brukes for N-dimensjonal interpolering av spredte data. I henhold til definisjonen tilsvarer den radiale basisfunksjonen et konstant referansedatapunkt. Scipy.Interpolat.RBF-klasse brukes til å interpolere funksjonene rett fra N-D-spredte data til et M-D-domene med bruk av radiale basisfunksjoner.

Følgende vedlagte skjermbilde viser hele koden. Her importerer vi RBF- og Numpy -modulene. Etter det genereres verdiene for XS_VAL og YS_VAL ved bruk av Arange () og Numpy.Sin () Metoder. En utskriftsuttalelse brukes til å vise meldingen "Here You Can See the Result". En "Res" -variabel opprettes der RBF -metoden brukes og den genererte XS_VAL og YS_VAL sendes som parametere. Etter det kan ZZ sees der det genereres en liste over tall for det spesifiserte området. Endelig vises resultatet.

Fra scipy.Interpolate import RBF
Importer numpy
xs_val = numpy.Arange (8)
ys_val = xs_val ** 3 + numpy.sin (xs_val) + 2
trykk ("Her kan du se resultatet:")
res = rbf (xs_val, ys_val)
zz = res (numpy.Arange (2.1, 3, 0.1))
trykk (ZZ)

Følgende er utgangen der en serie med tall genereres fra den forrige koden der RBF -metoden brukes.

Konklusjon

I denne artikkelen diskuterte vi hva Scipy Interpolate -konseptet er. Dets grunnleggende typer og de overordnede detaljene er dekket her. Du kan enkelt finne alle kravene angående nevnte emne i detalj med programmeringseksempler. Vi diskuterte hver for seg alle typene (1-D interpolasjon, spline-interpolasjon, univariat spline interpolasjon og RBF-interpolasjon) med riktige forklaringer og eksempler slik at du kan forstå hele konseptet bedre.