Articles

numpy standardafvigelse forklaret

by admin

denne vejledning forklarer, hvordan du bruger numpy standardafvigelsesfunktionen (AKA, np.kønssygdomme).

på et højt niveau er Numpy-standardafvigelsesfunktionen enkel. Den Beregner standardafvigelsen af værdierne i en Numpy array.

men detaljerne om præcis, hvordan funktionen fungerer, er lidt komplekse og kræver en forklaring.

når det er sagt, vil denne vejledning forklare, hvordan du bruger numpy standardafvigelsesfunktionen.

det vil forklare syntaksen for np.std (), og vise dig klare, trin-for-trin eksempler på, hvordan funktionen fungerer.

vejledningen er organiseret i sektioner. Du kan klikke på et af følgende links, som fører dig til det relevante afsnit.

Indholdsfortegnelse:

  • en meget hurtig gennemgang af Numpy
  • Introduktion til Numpy standardafvigelse
  • syntaksen for NP.STD
  • numpy standardafvigelse eksempler
  • numpy standardafvigelse ofte stillede spørgsmål

når det er sagt, hvis du er relativt ny til Numpy, kan du læse hele tutorial.

en hurtig gennemgang af Numpy

lad os bare starte med en veeery hurtig gennemgang af Numpy.

Hvad er Numpy?

Numpy er et værktøjssæt til at arbejde med numeriske data

for at sige det enkelt er Numpy et værktøjssæt til at arbejde med numeriske data.

for det første har Numpy et sæt værktøjer til oprettelse af en datastruktur kaldet et numpy-array.

Du kan tænke på en Numpy array som en række-og-kolonne gitter af tal. Numpy arrays kan være 1-dimensionelle, 2-dimensionelle eller endda n-dimensionelle.

et 2D-array ser sådan ud:

et eksempel på et 2-dimensionelt numpy-array med tallene 0 til 7.

for enkelhedens skyld holder vi os til 1 eller 2-dimensionelle arrays.

der er forskellige måder at oprette forskellige typer arrays med forskellige slags tal. Et par andre værktøjer til at skabe Numpy arrays omfatter numpy arrangere, numpy nuller, numpy dem, numpy flise, og andre metoder.

uanset hvordan du opretter dit Numpy array, på et højt niveau, er de simpelthen arrays af tal.

Numpy giver værktøjer til at manipulere Numpy arrays

Numpy giver ikke kun værktøjer til at skabe Numpy arrays, numpy giver også værktøjer til at arbejde med Numpy arrays.

nogle af de vigtigste af disse numpy-værktøjer er Numpy-funktioner til udførelse af beregninger.

Der er et helt sæt Numpy-funktioner til at gøre ting som:

  • beregning af summen af et numpy-array
  • beregning af det maksimale
  • beregning af eksponentiel af tallene i et array
  • beregning af værdien til en vis effekt for hver værdi i et Numpy-array

… og en række andre beregninger.

Numpy-standardafvigelsen er i det væsentlige meget som disse andre numpy-værktøjer. Det er bare bruges til at udføre en beregning (standardafvigelsen) af en gruppe af tal i en Numpy array.

en hurtig introduktion til Numpy standardafvigelse

på et meget højt niveau er standardafvigelse et mål for spredningen af et datasæt. Det er især et mål for, hvor langt datapunkterne er fra gennemsnittet af dataene.

lad os kort gennemgå den grundlæggende beregning.

standardafvigelse beregnes som kvadratroden af variansen.

så hvis vi har et datasæt med N tal, vil variansen være:

\begin{ligning*} \frac{1}{N} \displaystyle\sum_{i=1}^n (h_i - \overline{H})^2 \end{ligning*}

og standardafvigelsen vil bare være kvadratroden af variansen:

\begynd{ligning*} \KVRT{\frac{1}{n} \displaystyle\sum_{i=1}^n (h_i - \overline{H})^2} \slut{ligning*}

hvor:

h_i = de individuelle værdier i datasættet
N = antallet af værdier i datasættet
\overline{h} = gennemsnittet af værdierne h_i

det meste af tiden er beregning af standardafvigelse for hånd lidt udfordrende, fordi du skal beregne gennemsnittet, afvigelserne for hvert datapunkt fra gennemsnittet, derefter kvadratet af afvigelserne osv. Helt ærligt er det lidt kedeligt.

men hvis du arbejder i Python, kan du bruge funktionen Numpy standardafvigelse til at udføre beregningen for dig.

en hurtig note, hvis du er ny til statistik

fordi dette blogindlæg handler om at bruge numpy.std () funktion, Jeg ønsker ikke at komme for dybt ind i ukrudtet om, hvordan beregningen udføres manuelt. Denne tutorial handler virkelig om, hvordan vi bruger funktionen. Så hvis du har brug for en hurtig gennemgang af, hvad standardafvigelse er, kan du se denne video.

Ok. Når vi hurtigt har gennemgået, hvad standardafvigelse er, lad os se på syntaksen for np.kønssygdomme.

syntaksen for np.STD

syntaksen for numpy-standardafvigelsesfunktionen er ret enkel.

Jeg forklarer det på bare et sekund, men først vil jeg fortælle dig en hurtig note om Numpy syntaks.

en hurtig note: den nøjagtige syntaks afhænger af, hvordan du importerer Numpy

Når vi skriver Numpy-syntaks, bruger vi typisk aliaset “np”. Det er den fælles konvention blandt de fleste dataforskere.

for at indstille det alias skal du importere Numpy som denne:

import numpy as np

Hvis vi importerer Numpy med dette alias, kan vi kalde Numpy standardafvigelsesfunktionen somnp.std().

Ok, når det er sagt, lad os se nærmere på syntaksen.

np.STD syntaks

på et højt niveau, syntaksen for np.std ser sådan ud:

et billede, der forklarer syntaksen for Numpy standardafvigelse.

som jeg nævnte tidligere, forudsat at vi har importeret Numpy med aliaset “np” vi kalder funktionen med syntaksennp.std().

så inde i parentesen er der flere parametre, der giver dig mulighed for at kontrollere nøjagtigt, hvordan funktionen fungerer.

lad os se på disse parametre.

parametrene for numpy.std

Der er et par vigtige parametre, du bør vide:

  • a
  • axis
  • dtype
  • ddof
  • keepdims
  • out

lad os se på hver af dem.

a(påkrævet)

parameterena angiver det array af værdier, som du vil beregne standardafvigelsen over.

sagt anderledes, Dette giver dig mulighed for at angive input array til funktionen.

passende indgange omfatter Numpy arrays, men også “array lignende” objekter såsom Python lister.

det er vigtigt, at du giver et input til denne parameter. Et input er påkrævet.

når det er sagt, kan parameteren selv være implicit eller eksplicit. Hvad jeg mener med det er, at du direkte kan skrive parameteren a=, eller du kan forlade parameteren ud af din syntaks og bare skrive navnet på dit input array.

Jeg vil vise dig eksempler på dette i eksempel 1.

axis

akseparameteren giver dig mulighed for at specificere en akse, langs hvilken standardafvigelsen beregnes.

for at forstå dette skal du virkelig forstå akser.

Numpy arrays har akser.

Du kan tænke på en” akse ” som en retning langs arrayet.

i et 2-dimensionelt array vil der være 2 akser: akse-0 og akse-1.

i et 2D-array peger akse-0 nedad langs rækkerne og akse-1 peger vandret langs kolonnerne.

visuelt kan du visualisere akserne i et 2D-array som dette:

et visuelt eksempel på NumPy array akser.

Ved hjælp af parameterenaxis kan du beregne standardafvigelsen i en bestemt retning langs arrayet.

dette illustreres bedst med eksempler, så jeg viser dig et eksempel i eksempel 2.

(for en fuldstændig forklaring af Numpy array akser, se vores tutorial kaldet Numpy akser forklaret.)

dtype

(valgfrit)
parameterendtype giver dig mulighed for at angive den datatype, du vil bruge, når np.std Beregner standardafvigelsen.

hvis dataene i inputarrayet er heltal, vil dette som standard være float64.

ellers, hvis dataene i inputarrayet flyder, vil dette som standard være den samme float-type som inputarrayet.

ddof

(valgfrit)
Dette giver dig mulighed for at specificere “frihedsgrader” til beregningen.

for at forstå dette skal du se på ligning 2 igen.

\

i denne ligning er det første udtryk\frac{1}{n}.

husk:N er antallet af værdier i arrayet eller datasættet.

men hvis vi tænker statistisk, er der faktisk en forskel mellem at beregne en populationsstandardafvigelse vs en stikprøvestandardafvigelse.

Hvis vi beregner en populationsstandardafvigelse, bruger vi udtrykket\frac{1}{n} i vores ligning.

men når vi beregner standardafvigelsen på en prøve af data (en prøve afndatapoints), så er vi nødt til at ændre ligningen, så det førende udtryk er\frac{1}{n - 1}. I så fald bliver ligningen for en prøvestandardafvigelse:

\begin{ligning*} S_{sample} = \frac {1} {n - 1}\displaystyle \sum_{i=1}^n (h_i - \overline{H})^2} \end{ligning*}

hvordan implementerer vi dette med NP.std?

Vi kan gøre dette med parameterenddof ved at indstilleddof = 1.

og faktisk kan vi indstille ddof sigt mere generelt. Når vi bruger ddof, vil det ændre standardafvigelsesberegningen til at blive:

\begynd{ligning*} \KVRT{\frac{1}{n - ddof} \displaystyle\sum_{i=1}^N^2} \end{ligning*}

for at være ærlig er dette lidt teknisk. Hvis du har brug for at lære mere om dette, du skal se denne video på Khan academy om frihedsgrader, og befolkning vs prøve standardafvigelse.

out

(valgfrit)
parameterenout giver dig mulighed for at specificere et alternativt array, hvor output skal placeres.

det skal have samme form som det forventede output.

keepdims

(valgfrit)
keepdims parameter kan bruges til at “holde” det oprindelige antal dimensioner. Når du indstiller keepdims = True, vil output have det samme antal dimensioner som input.

Husk: når vi beregner standardafvigelsen, vil beregningen “kollapse” antallet af dimensioner.

for eksempel, hvis vi indtaster et 2-dimensionelt array som input, så som standard np.std udsender et nummer. En skalar værdi.

men hvis vi ønsker, at output skal være et tal inden for et 2D-array (dvs.et outputarray med de samme dimensioner som input), kan vi indstillekeepdims = True.

for at være ærlig er nogle af disse parametre lidt abstrakte, og jeg tror, de vil give meget mere mening med eksempler.

lad os se på nogle eksempler.

eksempler på, hvordan du bruger Numpy standardafvigelse

Her gennemgår vi et par eksempler. Vi starter simpelt og derefter øge kompleksiteten.

eksempler:

  • Beregn standardafvigelse for et 1-dimensionelt array
  • Beregn standardafvigelsen for et 2-dimensionelt array
  • brug np.std for at beregne standardafvigelserne for kolonnerne
  • brug np.std for at beregne standardafvigelserne for rækkerne
  • ændre frihedsgraderne
  • brug parameteren keepdims i np.std

Kør denne kode først

før du kører en af eksempelkoden, skal du importere Numpy.

for at gøre dette kan du køre følgende kode:

import numpy as np

dette importerer Numpy med aliaset “np“.

eksempel 1: Beregn standardafvigelse for et 1-dimensionelt array

Her starter vi simpelt.

Vi skal beregne standardafvigelsen for 1-dimensionelt numpy array.

Opret 1D array

først opretter vi bare vores 1D array: 

array_1d = np.array()
Beregn standard dev

nu beregner vi standardafvigelsen for disse tal.

np.std(array_1d)

OUT:

30.84369195367723

Så hvad skete der her?

np.STD-funktion beregnede bare standardafvigelsen for tallene ved hjælp af ligning 2, som vi så tidligere. Hvert tal er et af i den ligning.

en hurtig note

i ovenstående eksempel brugte vi ikke eksplicit parameterena=. Det skyldes np.std forstår, at når vi giver et argument til funktionen som i koden np.std(array_1d), skal indgangen sendes til a parameter.

Alternativt kan du også eksplicit brugea= parameter: 

np.std(a = array_1d)

OUT: 

30.84369195367723

eksempel 2: Beregn standardafvigelsen for et 2-dimensionelt array

Ok. Lad os nu se på et eksempel med et 2-dimensionelt array.

Opret 2-dimensionelt array

Her skal vi oprette et 2D-array ved hjælp af np.tilfældig.randint funktion.

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

dette array har 3 rækker og 4 kolonner.

lad os udskrive det, så vi kan se det.

print(array_2d)

OUT:

 ]

Dette er bare et 2D-array, der indeholder 12 tilfældige heltal mellem 0 og 20.

Beregn standardafvigelse med np.std

Okay, lad os beregne standardafvigelsen.

np.std(array_2d)

ud:

5.007633062524539

Her, numpy.std () beregner bare standardafvigelsen for alle 12 heltal.

standardafvigelsen er5.007633062524539.

eksempel 3: Beregn standardafvigelsen for kolonnerne

nu skal vi beregne standardafvigelsen for kolonnerne.

for at gøre dette skal vi bruge parameteren axis. (Du lærte om parameteren axis i afsnittet om parametrene for numpy.std)

specifikt skal vi indstille axis = 0.

hvorfor?

som jeg nævnte i forklaringen af axis parameter tidligere, Numpy arrays har akser.

i et todimensionelt array er akse-0 den akse, der peger nedad.

et NumPy-array, der viser, at akse = 0 er aksen ned ad rækkerne i arrayet.

Når vi bruger numpy.std med axis = 0, der beregner standardafvigelserne nedad i aksen-0 retning.

lad os se på et eksempel, så du kan se, hvad jeg mener.

Opret 2-dimensionelt array

først opretter vi et 2D-array ved hjælp af np.tilfældig.randint funktion.

(Dette er det samme array, som vi oprettede i eksempel 2, så hvis du allerede har oprettet det, skal du ikke oprette det igen.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

lad os udskrive det, så vi kan se det.

print(array_2d)

OUT:

 ]

Dette er bare et 2D-array, der indeholder heltal mellem 0 og 20.

brug np.std for at beregne standardafvigelsen for kolonnerne

nu indstiller vi axis = 0 inde i np.std at beregne standardafvigelser af kolonnerne.

np.std(array_2d, axis = 0)

ud:

array()
forklaring

Hvad sker der her?

Når vi bruger np.std med axis = 0, numpy Beregner standardafvigelsen nedad i aksen-0 retning. Husk, som jeg nævnte ovenfor, akse – 0 peger nedad.

dette har den virkning at beregne standardafvigelsen for hver kolonne i numpy-arrayet.

et billede, der viser, hvordan man bruger Numpy standardafvigelse med akse = 0 til at beregne kolonnens standardafvigelser.

lad os nu lave et lignende eksempel med rækken standardafvigelser.

eksempel 4: Brug np.std til at beregne standardafvigelserne for rækkerne

nu skal vi bruge np.std at beregne standardafvigelser vandret langs en 2D numpy array.

Husk hvad jeg sagde tidligere: numpy arrays har akser. Akserne er som retninger langs Numpy-arrayet. I et 2D-array peger akse-1 vandret som dette:

et billede, der viser, hvordan akse-1 peger vandret langs et 2D Numpy array.

så hvis vi vil beregne standardafvigelserne vandret, kan vi indstilleaxis = 1. Dette har den virkning at beregne rækken standardafvigelser.

lad os tage et kig.

Opret 2-dimensionelt array

for at køre dette eksempel har vi igen brug for et 2D Numpy-array, så vi opretter et 2D-array ved hjælp af np.tilfældig.randint funktion.

(Dette er det samme array, som vi oprettede i eksempel 2, så hvis du allerede har oprettet det, skal du ikke oprette det igen.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

lad os udskrive det, så vi kan se det.

print(array_2d)

OUT:

 ]

Dette er bare et 2D-array, der indeholder heltal mellem 0 og 20.

brug np.std til at beregne standardafvigelse af rækkerne

nu bruger vi np.std med axis = 1 for at beregne standardafvigelserne for rækkerne.

np.std(array_2d, axis = 1)

ud:

array()
forklaring

Hvis du forstod eksempel 3, skulle dette nye eksempel give mening.

Når vi bruger np.STD og set axis = 1, numpy beregner standardafvigelserne vandret langs akse-1.

et billede, der viser ved hjælp af np.std med akse = 1 For at beregne rækken standardafvigelser.

effektivt, når vi bruger Numpy standardafvigelse medaxis = 1, beregner funktionen standardafvigelsen for rækkerne.

eksempel 5: Skift frihedsgraderne

lad os nu ændre frihedsgraderne.

her i dette eksempel skal vi oprette et stort udvalg af tal, tage en prøve fra det array og beregne standardafvigelsen på den prøve.

lad os først oprette vores arrays.

Opret Numpy array

først opretter vi bare et normalt distribueret numpy array med et gennemsnit på 0 og en standardafvigelse på 10.

for at gøre dette bruger vi numpy tilfældig normal funktion. Bemærk, at vi bruger numpy random seed-funktionen til at indstille frøet til random number generator. For mere information om dette, læs vores tutorial om np.tilfældig.frø.

np.random.seed(22)population_array = np.random.normal(size = 100, loc = 0, scale = 10)

Ok. Nu har vi et Numpy array, population_array, der har 100 elementer, der har et gennemsnit på 0 og en standardafvigelse på 10.

Opret prøve

nu bruger vi Numpy random choice til at tage en tilfældig prøve fra Numpy-arrayet,population_array.

np.random.seed(22)sample_array = np.random.choice(population_array, size = 10)

dette nye array,sample_array, er en tilfældig prøve af 10 elementer frapopulation_array.

Vi brugersample_array når vi beregner vores standardafvigelse ved hjælp af parameterenddof.

Beregn standardafvigelsen for prøven

nu beregner vi standardafvigelsen for prøven.

specifikt skal vi bruge numpy-standardafvigelsesfunktionen medddofparameteren indstillet tilddof = 1.

np.std(sample_array, ddof = 1)

OUT:

10.703405562234051
forklaring

Her har vi beregnet:

\

og når vi indstiller ddof = 1, ligningen evalueres til:

\

for at være klar, når du beregner standardafvigelsen for en prøve, indstiller du ddof = 1.

for at være ærlig er detaljerne om hvorfor lidt tekniske (og uden for rammerne af dette indlæg), så for mere information om beregning af en prøvestandardafvigelse anbefaler jeg, at du ser denne video.

Husk, at du i nogle andre tilfælde kan indstilleddof til andre værdier udover 1 eller 0. Hvis du slet ikke bruger parameteren ddof, vil den som standard være 0.

uanset hvilken værdi du vælger, beregner numpy-standardafvigelsesfunktionen standardafvigelsen med ligningen:

\

eksempel 6: Brug keepdims-parameteren i NP.std

Ok. Endelig vil vi gøre et sidste eksempel.

Her skal vi indstillekeepdimsparameter tilkeepdims = True.

Opret 2-dimensionelt array

først opretter vi et 2D-array ved hjælp af np.tilfældig.randint funktion.

(Dette er det samme array, som vi oprettede i eksempel 2, så hvis du allerede har oprettet det, skal du ikke oprette det igen.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

lad os udskrive det: 

print(array_2d)

OUT: 

 ]
kontroller dimensionerne

lad os nu se på dimensionerne af dette array.

array_2d.ndim

OUT:

2

Dette er et 2D-array, ligesom vi havde til hensigt.

Beregn standardafvigelsen, og kontroller dimensionerne

Ok. Nu skal vi beregne standardafvigelsen og kontrollere dimensionerne af output.

output = np.std(array_2d)

lad os hurtigt udskrive output: 

print(output)

OUT: 

5.007633062524539

så standardafvigelsen er 5.007633062524539.

nu, Hvad er dimensionerne af output?

output.ndim

ud:

0

udgangen har 0 dimensioner (det er en skalar værdi).

hvorfor?

Når np.std Beregner standardafvigelsen, det beregner en sammenfattende statistik. I dette tilfælde tager funktionen et stort antal værdier og kollapser dem ned til en enkelt metrisk.

så indgangen var 2-dimensionel, men udgangen er 0-dimensionel.

Hvad hvis vi vil ændre det?

Hvad hvis vi ønsker, at output teknisk set har 2-dimensioner?

Vi kan gøre det med parameteren keepdims.

behold de oprindelige dimensioner, når vi bruger np.std

Her indstiller vikeepdims = True for at gøre output de samme dimensioner som input.

output_2d = np.std(array_2d, keepdims = True)

lad os nu se på output: 

print(output_2d)

OUT: 

]

Bemærk, at output, standardafvigelsen, stadig er 5.00763306. Men resultatet er lukket inde i dobbeltbeslag.

lad os inspicere output_2d og se nærmere på.

type(output_2d)

OUT:

numpy.ndarray

så output_2d er et Numpy array, ikke en skalær værdi.

lad os kontrollere dimensionerne: 

output_2d.ndim

OUT: 

2

dette numpy array,output_2d, har 2 dimensioner.

Dette er det samme antal dimensioner som input.

Hvad skete der?

Når vi indstillerkeepdims = True, der forårsagede np.std-funktion til at producere et output med det samme antal dimensioner som input. Selvom der ikke er nogen rækker og kolonner i output, har output output_2d 2 dimensioner.

så hvis du nogensinde har brug for dit output for at have det samme antal dimensioner som dit input, kan du indstillekeepdims = True.

(Dette fungerer også, når du bruger parameteren axis … prøv det!)

ofte stillede spørgsmål om Numpy standardafvigelse

nu hvor du har lært om Numpy standardafvigelse og set nogle eksempler, lad os gennemgå nogle ofte stillede spørgsmål om np.kønssygdomme.

ofte stillede spørgsmål:

  • Hvorfor giver numpy std() et andet resultat end matlab std () eller et andet programmeringssprog?

spørgsmål 1: Hvorfor giver numpy std() et andet resultat end matlab std() eller et andet programmeringssprog?

den enkle grund er, at matlab beregner standard dev i henhold til følgende:

\

(mange andre værktøjer bruger den samme ligning.)

numpy beregner dog med følgende:

\

Bemærk den subtile forskel mellem \frac{1}{n - 1} vs \frac{1}{n}.

for at løse dette kan du bruge parameteren ddof i numpy.

Hvis du bruger np.std med parameteren ddof indstillet til ddof = 1, skal du få det samme svar som matlab.

Efterlad dine andre spørgsmål i kommentarerne nedenfor

har du andre spørgsmål om Numpy-standardafvigelsesfunktionen?

efterlad dit spørgsmål i kommentarfeltet nedenfor.

Deltag i vores kursus for at lære mere om Numpy

de eksempler, du har set i denne tutorial, skal være nok til at komme i gang, men hvis du er seriøs med at lære Numpy, skal du tilmelde dig vores premium-kursus kaldet Numpy Mastery.

der er meget mere at lære om Numpy, og Numpy Mastery vil lære dig alt, herunder:

  • Sådan oprettes Numpy arrays
  • Sådan bruges numpy tilfældige funktioner
  • hvad funktionen “numpy random seed” gør
  • sådan omformes, opdeles og kombineres dine Numpy arrays
  • og mere …

desuden hjælper det dig med at mestre syntaksen inden for et par uger. Du vil opdage, hvordan man bliver “flydende” skriftligt Numpy kode.

Find ud af mere her:

Lær mere om Numpy Mastery