Numpy gradientmetode

Numpy -biblioteket levert av Python -programmeringsspråket er et av de beste bibliotekene som lar deg utføre hvilken som helst matematisk beregning på matriser. I denne guiden vil vi diskutere numpy gradientmetoden. Mot slutten av denne opplæringen vil du kunne bruke gradientmetoden i Python -programmene dine på egen hånd.

Hva er gradienten på Python -programmeringsspråket?

Generelt er gradienten en vektor som inneholder de delvise derivater av variablene. For eksempel har en 2-D-matrise to gradientvektorer. En 5-D-matrise har fem gradientvektorer, og så videre. På Python-programmeringsspråket er konseptet med gradienten det samme, men vi har en innebygd gradientmetode for å finne gradienten til en flerdimensjonal matrise.

Hva er den numpy gradientmetoden?

Den numpy gradientmetoden beregner de gitte dataens gradient ved å finne interiørets sentrale forskjeller. Dataens gradient refererer til endringen i y -dimensjonen over endringen i X -dimensjonen, og den numpy gradientmetoden beregner gradienten til de medfølgende dataene. Vi vil forklare dette ved hjelp av enkle eksempler. Men før vi demonstrerer eksemplene, la oss hjelpe deg med å forstå syntaksen til numpy gradientmetoden.

Syntaks av numpy gradientmetode

Syntaksen til numpy gradientmetoden er som følger:

Den numpy gradientmetoden tar fem inngangsparametere, matrise, *args, akse og kanter. "Array" -parameteren inneholder inngangsoppstillingen som gradientfunksjonen må brukes. Parameteren "*args" refererer til listen over matriser eller skalarer. "Axis" -parameteren refererer til beregningenes akse, enten 0 eller 1. 0-aksen representerer beregningen på raden på radnivå, og aksen 1 representerer dataene på kolonnivånivå. Det er en valgfri parameter. Og til slutt er en annen valgfri parameter "kanter" med standardverdi 1, som representerer de nth ordenens nøyaktige forskjeller ved grensene.

Nå som vi forstår hva gradient er, numpy gradientmetode og syntaks, la oss bruke numpy gradientmetoden i prøveprogrammer for å forstå bedre.

Eksempel 1

Vi starter med et veldig enkelt og grunnleggende eksempel slik at du ikke har problemer med å forstå arbeidet med den numpy gradientmetoden. Koden er gitt nedenfor for din referanse, se den først, og deretter vil vi forklare hvert trinn en-for-en:

Importer numpy som npy
y = [1, 5, 9, 11]
trykk ('gradienten er:', npy.gradient (y))

Programmet startet med å importere Numpy -biblioteket med "Importer Numpy as NPY" -uttalelsen. Funksjonen til Numpy Library vil ikke fungere hvis du ikke eksplisitt inkluderer Numpy -biblioteket i programmet. Når vi har importert det numpy biblioteket referert til av en variabel, kan vi bruke variabelen til å ringe hvilken som helst funksjon fra biblioteket. Etter å ha importert det numpy biblioteket, er en matrise erklært i variabelen “y” som inneholder fire verdier. Den deklarerte matrisen sendes til gradient () -funksjonen for å finne gradienten til matrisen. Gradient () -metoden på skjermens bakgrunn vil utføre følgende trinn:

(y [1] - y [0]) / 1 = (5 - 1) / 1 = 4 /1 = 4
(y [2] - y [0]) / 2 = (9 - 1) / 2 = 8/2 = 4
(y [3] - y [1]) / 2 = (11 - 5) / 2 = 6/2 = 3
(y [3] - y [2]) / 1 = (11 - 9) / 1 = 2/1 = 2

I henhold til beregningen vil vi få [4, 4, 3, 2] resultatet av gradienten () -funksjonen. La oss bekrefte resultatet i utgangen gitt nedenfor:

Eksempel 2

Tidligere beregnet vi gradienten til en matrise og lærte trinnene som ble utført på backend ved numpy gradientmetode. Nå vil vi tilby to matriser til gradienten () -funksjonen for å beregne gradienten ().

Importer numpy som npy
x = [1, 5, 9, 11]
y = [13, 15, 19, 21]
trykk ('gradienten er:', npy.gradient (y, x))

Her importerte vi Numpy -biblioteket med "Importer Numpy as NPY" -erklæringen i programmet. Ved hjelp av NPY -variabelen vil vi bruke gradient () -funksjonen til Numpy Library. To matriser, X og Y, er erklært, som hver har fire elementer. Begge matriser, X og Y, sendes til gradientfunksjonen for å beregne gradienten. Følgende trinn vil bli utført ved numpy gradientmetode ved backend for å beregne gradienten til to matriser:

(y [1] - y [0]) / (x [1] - x [0]) = (15 - 13) / (5 - 1) = 2 /4 = 0.5
(y [2] - y [0]) / (x [2] - x [0]) = (19 - 13) / (9 - 1) = 6/8 = 0.75
(y [3] - y [1]) / (x [3] - x [1]) = (21 - 15) / (11 - 5) = 6/6 = 1
(y [3] - y [2]) / (x [3] - x [2]) = (21 - 19) / (11 - 9) = 2/2 = 1

Derfor bør den resulterende gradientgruppen være [0.5, 0.75, 1, 1]. La oss bekrefte dette i utgangen gitt nedenfor:

Eksempel 3

I tidligere eksempler ga vi bare matrisene til gradientfunksjonen og ignorerte alle andre parametere som kan gis til Numpy Gradient -metoden. Så i dette eksempeleksemplet vil vi lære hvordan du kan gi alle parametrene til gradienten () -funksjonen. Referansekoden er gitt i følgende skjermbilde:

Importer numpy som npy
x = npy.Array ([[1, 5, 9, 11], [1, 2, 4, 8]], dtype = int)
Axis = 1
kanter = 2
trykk ('gradienten er:', npy.gradient (x, akse, kanter))

Som du kan se, importeres Numpy -biblioteket til programmet som NPY, og NPY brukes til å kalle matrisen () og Gradient (). En 2-dimensjonal matrise opprettes ved å bruke array () -funksjonen sammen med at aksen = 1 og kanter = 2 er erklært. Alle disse parametrene ført til gradientfunksjonen. La oss nå se følgende utdata for å sjekke resultatet at gradienten () -funksjonen har produsert. Her er følgende utgang:

Konklusjon

Denne artikkelen hadde som mål å lære den numpy gradientmetoden ved hjelp av enkle eksempler. Den numpy gradientmetoden brukes til å sjekke endringen i y -dimensjonen over endringen i X -dimensjonen. Gradientmetoden er en rask og effektiv måte å få gradienten til de gitte dataene uten å møte noen feil du kan gjøre i manuell beregning. Disse prøvekodene vil hjelpe deg med å skrive det tilpassede programmet ditt, inkludert Numpy Gradient -metoden.