Ez az oktatóanyag elmagyarázza, hogyan kell használni a numpy szórás funkciót (más néven np.std).

magas szinten a numpy szórás funkció egyszerű. Kiszámítja az értékek szórását egy Numpy tömbben.

de a függvény működésének részletei egy kicsit összetettek, és némi magyarázatot igényelnek.

ennek ellenére ez az oktatóanyag elmagyarázza, hogyan kell használni a numpy szórás funkciót.

elmagyarázza az np szintaxisát.std (), és megmutatja egyértelmű, lépésről-lépésre példákat, hogyan működik a függvény.

az oktatóanyag szakaszokra van osztva. A következő linkek bármelyikére kattinthat, amely a megfelelő szakaszba vezet.

Tartalomjegyzék:

• a Numpy nagyon gyors áttekintése
• Bevezetés a numpy szórásba
• az np szintaxisa.std
• numpy szórási példák
• numpy szórási GYIK

miután elmondta, hogy ha viszonylag új vagy a Numpy-ban, érdemes elolvasni az egész oktatóanyagot.

A numpy gyors áttekintése

kezdjük csak a numpy gyors áttekintésével.

mi az a Numpy?

Numpy egy eszköztár dolgozó numerikus adatok

egyszerűen fogalmazva, Numpy egy eszköztár dolgozó numerikus adatokat.

először is, a Numpy rendelkezik egy eszközkészlettel egy numpy tömbnek nevezett adatstruktúra létrehozásához.

gondolhat egy Numpy tömbre, mint a számok sor-oszlop rácsára. A Numpy tömbök lehetnek 1 dimenziós, 2 dimenziós vagy akár n dimenziós.

egy 2D tömb valahogy így néz ki:

az egyszerűség kedvéért ebben az oktatóanyagban ragaszkodunk az 1 vagy 2 dimenziós tömbökhöz.

sokféle módon lehet különböző típusú tömböket létrehozni különböző típusú számokkal. Néhány más eszközök létrehozására numpy tömbök közé numpy intézkedik, numpy nullák, numpy is, numpy csempe, és egyéb módszerek.

függetlenül attól, hogy hogyan hozza létre a Numpy tömböt, magas szinten, ezek egyszerűen számok tömbjei.

A Numpy eszközöket biztosít a numpy tömbök manipulálásához

a Numpy nemcsak a numpy tömbök létrehozásához nyújt eszközöket, hanem a numpy tömbök kezeléséhez is.

ezek közül a numpy eszközök közül néhány a numpy függvény a számítások elvégzéséhez.

van egy egész sor Numpy funkciók a dolgok, mint:

• egy numpy tömb összegének kiszámítása
• a maximális
• a tömbben lévő számok exponenciális értékének kiszámítása
• az X érték kiszámítása valamilyen teljesítményre, a Numpy tömb minden értékére

… és számos más számítás.

a numpy szórás lényegében sokban hasonlít ezekre a többi Numpy eszközre. Csak egy számcsoport számításának (szórásának) elvégzésére használják a Numpy tömb.

gyors bevezetés a numpy szórásba

nagyon magas szinten a szórás az adatkészlet terjedésének mértéke. Különösen azt méri, hogy az adatpontok milyen messze vannak az adatok átlagától.

röviden áttekintjük az alapvető számítást.

a szórást a variancia négyzetgyökeként számítjuk ki.

tehát ha van egy adatkészletünk számokkal, akkor a variancia:

és a szórás csak a variancia négyzetgyöke lesz:

ahol:

= az egyes értékek az adatkészletben
= az értékek száma az adatkészletben
= az értékek átlaga

a szórás kézi kiszámítása legtöbbször kissé kihívást jelent, mert ki kell számítania az átlagot, az egyes adatpontok eltéréseit az átlagtól, majd az eltérések négyzetét stb. Őszintén szólva, ez egy kicsit unalmas.

Ha azonban Pythonban dolgozik, akkor a numpy szórás függvény segítségével elvégezheti a számítást az Ön számára.

gyors megjegyzés, ha még nem ismeri a statisztikákat

mert ez a blogbejegyzés a numpy használatáról szól.std () függvény, nem akarok túl mélyen belemenni a gyomokba arról, hogy a számítást kézzel hajtják végre. Ez az oktatóanyag valóban arról szól, hogyan használjuk a funkciót. Tehát, ha gyors áttekintésre van szüksége arról, hogy mi a szórás, megnézheti ezt a videót.

Ok. Miután gyorsan áttekintettük, mi a szórás, nézzük meg az np szintaxisát.std.

az np szintaxisa.std

a numpy szórás függvény szintaxisa meglehetősen egyszerű.

csak egy másodperc alatt elmagyarázom, de először egy gyors megjegyzést szeretnék mondani a Numpy szintaxisról.

gyors megjegyzés: a pontos szintaxis attól függ, hogyan importálja a Numpy-t

általában, amikor Numpy szintaxist írunk, az “np”álnevet használjuk. Ez a közös konvenció a legtöbb adattudós között.

az alias beállításához így kell importálnia a Numpy-t:

import numpy as np

Ha ezzel az álnévvel importáljuk a Numpy-t, akkor a numpy szórási függvénytnp.std() néven hívhatjuk meg.

Ok, hogy azt mondta, vessünk egy közelebbi pillantást a szintaxis.

np.std szintaxis

magas szinten az np szintaxisa.az std valahogy így néz ki:

mint korábban említettem, feltételezve, hogy a Numpy-t a “np” álnévvel importáltuk, a függvényt szintaxissal hívjuk np.std().

ezután a zárójel belsejében számos olyan paraméter található, amelyek lehetővé teszik a funkció működésének pontos ellenőrzését.

nézzük meg ezeket a paramétereket.

A numpy paraméterei.std

van néhány fontos paraméter, amelyet tudnia kell:

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

vessünk egy pillantást mindegyikre.

a (kötelező)

aa paraméter határozza meg az értékek tömbjét, amelyek felett ki szeretné számítani a szórást.

mondta másképp, ez lehetővé teszi, hogy adja meg a bemeneti tömb a függvény.

a megfelelő bemenetek közé tartoznak a Numpy tömbök, de a “tömbszerű” objektumok, például a Python listák is.

fontos, hogy meg kell adnia egy bemenetet ehhez a paraméterhez. Bemenet szükséges.

miután ezt mondta, maga a paraméter lehet implicit vagy explicit. Ez alatt azt értem, hogy közvetlenül beírhatja a a= paramétert, vagy kihagyhatja a paramétert a szintaxisból, és csak írja be a bemeneti tömb nevét.

példákat mutatok erre az 1. példában.

axis

Az axis paraméter lehetővé teszi egy olyan tengely megadását, amely mentén a szórás kiszámításra kerül.

ennek megértéséhez valóban meg kell értenie a tengelyeket.

a Numpy tömböknek tengelyük van.

gondolhat egy “tengelyre”, mint egy irány a tömb mentén.

egy 2 dimenziós tömbben 2 tengely lesz: axis-0 és axis-1.

egy 2D tömbben a tengely-0 lefelé mutat a sorok mentén, a tengely-1 pedig vízszintesen az oszlopok mentén.

vizuálisan megjelenítheti a 2D tömb tengelyeit:

a axis paraméter segítségével kiszámíthatja a szórást egy adott irányban a tömb mentén.

Ez a legjobban példákkal illusztrálható, ezért mutatok egy példát a 2.példában.

(a numpy tömbtengelyek teljes magyarázatát lásd a numpy axes explained nevű oktatóanyagunkban.)

dtype

(opcionális)
adtype paraméter lehetővé teszi, hogy megadja a használni kívánt adattípust, amikor np.az std kiszámítja a szórást.

Ha a bemeneti tömb adatai egész számok, akkor ez alapértelmezés szerint float64.

ellenkező esetben, ha a bemeneti tömbben lévő adatok úszók, akkor ez alapértelmezés szerint ugyanolyan float típusú lesz, mint a bemeneti tömb.

ddof

(opcionális)
Ez lehetővé teszi a számítás “szabadságfokainak” megadását.

ennek megértéséhez újra meg kell vizsgálnia a 2.egyenletet.

ebben az egyenletben az első kifejezés.

ne feledje: a tömbben vagy az adatkészletben lévő értékek száma.

de ha statisztikai értelemben gondolkodunk, valójában különbség van a populáció szórásának kiszámítása és a minta szórásának kiszámítása között.

ha kiszámítunk egy populációs szórást, akkor az egyenletünkben a kifejezést használjuk.

amikor azonban kiszámítjuk a szórást egy adatmintán ( adatpontok mintája), akkor módosítanunk kell az egyenletet úgy, hogy a vezető kifejezés legyen. Ebben az esetben a minta szórásának egyenlete a következő lesz:

hogyan valósítjuk meg ezt np-vel.nemi betegség?

ezt a ddofparaméterrel tehetjük meg, a ddof = 1 beállításával.

sőt, a ddof kifejezést általánosabban is beállíthatjuk. Ha a ddof értéket használjuk, akkor a szórás számítása a következő lesz:

hogy őszinte legyek, ez egy kicsit technikai. Ha többet szeretne megtudni erről, nézze meg ezt a videót a Khan Akadémián a szabadság fokairól, valamint a népesség vs minta szórása.

out

(opcionális)
aout paraméter lehetővé teszi egy alternatív tömb megadását a kimenet elhelyezéséhez.

ugyanolyan alakúnak kell lennie, mint a várt kimenet.

keepdims

(opcionális)
akeepdims paraméter használható az eredeti méretek számának “megtartására”. A keepdims = True beállításakor a kimenet ugyanannyi dimenzióval rendelkezik, mint a bemenet.

ne feledje: amikor kiszámítjuk a szórást, a számítás “összeomlik” a dimenziók számát.

például, ha bemenetként egy 2 dimenziós tömböt adunk meg, akkor alapértelmezés szerint np.az std egy számot fog kiadni. Skaláris érték.

de ha azt akarjuk, hogy a kimenet egy 2D tömbön belüli szám legyen (azaz egy kimeneti tömb, amelynek méretei megegyeznek a bemenettel), akkor beállíthatjuk keepdims = True.

hogy őszinte legyek, ezeknek a paramétereknek egy része egy kicsit absztrakt, és azt hiszem, sokkal több értelme lesz a példákkal.

nézzünk meg néhány példát.

példák a numpy szórás használatára

itt néhány példát fogunk kidolgozni. Kezdjük az egyszerűt, majd növeljük a komplexitást.

példák:

• Számítsa ki az 1 dimenziós tömb szórását
• Számítsa ki a 2 dimenziós tömb szórását
• használja az np-t.std az oszlopok szórásának kiszámításához
• használja az np-t.std a sorok szórásának kiszámításához
• változtassa meg a szabadság fokát
• használja a keepdims paramétert np-ben.std

először futtassa ezt a kódot

mielőtt bármelyik példakódot futtatná, importálnia kell a Numpy-t.

ehhez a következő kódot futtathatja:

import numpy as np

Ez a Numpy-t importálja a “np “álnévvel.

1. példa: Számítsa ki az 1 dimenziós tömb szórását

itt kezdjük egyszerű.

kiszámítjuk az 1 dimenziós numpy tömb szórását.

hozzon létre 1D tömböt

először csak létrehozzuk az 1D tömböt:

array_1d = np.array()

Számítsa ki a standard dev

most kiszámoljuk ezeknek a számoknak a szórását.

np.std(array_1d)

OUT:

30.84369195367723

Tehát mi történt itt?

az np.az std függvény csak kiszámította a számok szórását a korábban látott 2.egyenlet segítségével. Minden szám az egyik ebben az egyenletben.

egy gyors megjegyzés

a fenti példában nem használtuk kifejezetten a a= paramétert. Ez azért van, mert np.az std megérti, hogy amikor argumentumot adunk a függvényhez, mint a kódban np.std(array_1d), a bemenetet át kell adni a a paraméternek.

Alternatív megoldásként kifejezetten használhatja aa= paramétert is:

np.std(a = array_1d)

OUT:

30.84369195367723

2.példa: Számítsa ki a 2 dimenziós tömb szórását

Ok. Most nézzünk meg egy példát egy 2 dimenziós tömbbel.

2 dimenziós tömb létrehozása

itt egy 2D tömböt fogunk létrehozni az np használatával.véletlen.randint funkció.

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

Ez a tömb 3 sorból és 4 oszlopból áll.

nyomtassuk ki, hogy lássuk.

print(array_2d)

OUT:

 ]

Ez csak egy 2D tömb, amely 12 véletlenszerű egész számot tartalmaz 0 és 20 között.

számítsa ki a szórást np – vel.std

Oké, számítsuk ki a szórást.

np.std(array_2d)

OUT:

5.007633062524539

itt, numpy.az std () csak kiszámítja mind a 12 egész szám szórását.

a szórás5.007633062524539.

3.példa: Számítsa ki az oszlopok szórását

most kiszámoljuk az oszlopok szórását.

ehhez a axis paramétert kell használnunk. (Megismerte a axis paramétert a numpy paramétereiről szóló szakaszban.Std)

pontosabban be kell állítanunk a axis = 0értéket.

miért?

amint azt a axis paraméter magyarázatában korábban említettem, a Numpy tömböknek tengelyük van.

kétdimenziós tömbben a tengely-0 az a tengely, amely lefelé mutat.

amikor a numpy-t használjuk.std axis = 0, amely kiszámítja a szórásokat lefelé a tengely-0 irányban.

nézzünk meg egy példát, hogy lássuk, mire gondolok.

2 dimenziós tömb létrehozása

először létrehozunk egy 2D tömböt az np használatával.véletlen.randint funkció.

(Ez ugyanaz a tömb, amelyet a 2. példában hoztunk létre, tehát ha már létrehozta, akkor nem kell újra létrehoznia.)

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

nyomtassuk ki, hogy lássuk.

print(array_2d)

OUT:

 ]

Ez csak egy 2D tömb, amely 0 és 20 közötti egész számokat tartalmaz.

használja az np-t.std az oszlopok szórásának kiszámításához

most beállítjuk aaxis = 0 értéket az np belsejében.std az oszlopok szórásának kiszámításához.

np.std(array_2d, axis = 0)

OUT:

array()

magyarázat

mi folyik itt?

amikor np-t használunk.std axis = 0 esetén a numpy kiszámítja a szórást lefelé a tengely-0 irányban. Ne feledje, mint már említettük, tengely-0 pont lefelé.

ennek az a hatása, hogy kiszámítja a numpy tömb minden oszlopának szórását.

most tegyünk egy hasonló példát a sor szórásaival.

4. példa: használja az np-t.std a sorok szórásának kiszámításához

most np-t fogunk használni.std A szórások vízszintes kiszámításához egy 2D numpy tömb mentén.

Emlékezz arra, amit korábban mondtam: a numpy tömböknek tengelyük van. A tengelyek olyanok, mint az irányok a Numpy tömb mentén. Egy 2D tömbben, tengely-1 pont vízszintesen, így:

tehát, ha vízszintesen akarjuk kiszámítani a szórásokat, beállíthatjuk a axis = 1értéket. Ennek az a hatása, hogy kiszámítja a sor szórásait.

nézzük meg.

2 dimenziós tömb létrehozása

a példa futtatásához ismét szükségünk lesz egy 2D Numpy tömbre, így létrehozunk egy 2D tömböt az np használatával.véletlen.randint funkció.

(Ez ugyanaz a tömb, amelyet a 2. példában hoztunk létre, tehát ha már létrehozta, akkor nem kell újra létrehoznia.)

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

nyomtassuk ki, hogy lássuk.

print(array_2d)

OUT:

 ]

Ez csak egy 2D tömb, amely 0 és 20 közötti egész számokat tartalmaz.

használja az np-t.std a sorok szórásának kiszámításához

most np-t fogunk használni.std axis = 1 a sorok szórásának kiszámításához.

np.std(array_2d, axis = 1)

OUT:

array()

magyarázat

ha megértette a 3.példát, akkor ennek az új példának értelme van.

amikor np-t használunk.std és setaxis = 1, A numpy kiszámítja a szórásokat vízszintesen az-1 tengely mentén.

hatékonyan, amikor a Numpy szórást használjuk a axis = 1 értékkel, a függvény kiszámítja a sorok szórását.

5. példa: Változtassa meg a szabadság fokát

most változtassuk meg a szabadság fokát.

ebben a példában egy nagy számtömböt fogunk létrehozni, mintát veszünk abból a tömbből, és kiszámítjuk a minta szórását.

először hozzuk létre a tömböket.

hozzon létre Numpy tömböt

először csak egy normálisan elosztott numpy tömböt hozunk létre, amelynek átlaga 0 és szórása 10.

ehhez a numpy random normal függvényt fogjuk használni. Vegye figyelembe, hogy a Numpy random seed funkciót használjuk a véletlenszám-generátor magjának beállításához. További információ erről, olvassa el az NP-ről szóló oktatóanyagunkat.véletlen.mag.

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

Ok. Most van egy Numpy tömb, population_array, amely 100 elemet tartalmaz, amelyek átlaga 0 és szórása 10.

minta létrehozása

most a numpy random choice segítségével véletlenszerű mintát veszünk a Numpy tömbből, population_array.

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

Ez az új tömb, sample_array, egy véletlenszerű minta 10 elemből population_array.

a sample_arrayértéket fogjuk használni, amikor a szórást a ddof paraméter segítségével számítjuk ki.

Számítsa ki a minta szórását

most kiszámítjuk a minta szórását.

pontosabban a numpy szórás függvényt fogjuk használni addof paraméter beállításaddof = 1.

np.std(sample_array, ddof = 1)

OUT:

10.703405562234051

magyarázat

itt kiszámoltuk:

amikor beállítjuk a ddof = 1 értéket, az egyenlet értéke:

hogy világos legyen, amikor kiszámítja a minta szórását, beállítja a ddof = 1értéket.

hogy őszinte legyek, a részletek arról, hogy miért egy kicsit technikai (és túlmutat ezen a poszton), ezért a minta szórásának kiszámításával kapcsolatos további információkért azt javaslom, hogy nézze meg ezt a videót.

ne feledje, hogy néhány más esetben a ddof értéket az 1 vagy 0 mellett más értékekre is beállíthatja. Ha egyáltalán nem használja a ddof paramétert, akkor alapértelmezés szerint 0 lesz.

nem számít, milyen értéket választ, a numpy szórás függvény kiszámítja a szórást a következő egyenlettel:

6.példa: használja a keepdims paramétert np-ben.std

Ok. Végül egy utolsó példát fogunk tenni.

itt fogjuk beállítani a keepdimsparamétert keepdims = True.

2 dimenziós tömb létrehozása

először létrehozunk egy 2D tömböt az np használatával.véletlen.randint funkció.

(Ez ugyanaz a tömb, amelyet a 2. példában hoztunk létre, tehát ha már létrehozta, akkor nem kell újra létrehoznia.)

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

nyomtassuk ki:

print(array_2d)

OUT:

 ]

ellenőrizze a méreteket

most vessünk egy pillantást a tömb méreteire.

array_2d.ndim

OUT:

2

Ez egy 2D tömb, ahogy terveztük.

Számolja ki a szórást, és ellenőrizze a méreteket

Ok. Most kiszámoljuk a szórást, és ellenőrizzük a kimenet méretét.

output = np.std(array_2d)

nyomtassuk ki gyorsan a kimenetet:

print(output)

OUT:

5.007633062524539

tehát a szórás 5,007633062524539.

mi a kimenet mérete?

output.ndim

OUT:

0

a kimenet 0 dimenzióval rendelkezik (ez egy skaláris érték).

miért?

amikor np.az std kiszámítja a szórást, egy összefoglaló statisztikát számít. Ebben az esetben a függvény nagyszámú értéket vesz fel, és egyetlen mutatóra bontja őket.

tehát a bemenet 2 dimenziós volt, de a kimenet 0 dimenziós.

mi van, ha ezen változtatni akarunk?

mi van, ha azt akarjuk, hogy a kimenet technikailag 2 dimenzióval rendelkezzen?

ezt a keepdims paraméterrel tehetjük meg.

tartsa meg az eredeti méreteket, amikor np-t használunk.std

itt állítjuk be a keepdims = True értéket, hogy a kimenet ugyanolyan méretű legyen, mint a bemenet.

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

most nézzük meg a kimenetet:

print(output_2d)

OUT:

]

figyeljük meg, hogy a kimenet, a szórás, még mindig 5.00763306. De az eredmény zárt belsejében kettős zárójelben.

vizsgáljuk meg aoutput_2d és nézzük meg közelebbről.

type(output_2d)

OUT:

numpy.ndarray

tehát,output_2d egy Numpy tömb, nem skalár érték.

ellenőrizzük a méreteket:

output_2d.ndim

OUT:

2

ennek a Numpy tömbnek,output_2d, 2 dimenziója van.

Ez ugyanannyi dimenzió, mint a bemenet.

mi történt?

amikor beállítjuk keepdims = True, ez okozta az np-t.std funkció, hogy olyan kimenetet állítson elő, amelynek mérete megegyezik a bemenettel. Annak ellenére, hogy nincsenek sorok és oszlopok a kimeneten, a output_2d kimenet 2 dimenzióval rendelkezik.

tehát, ha valaha is szüksége van a kimenetére, hogy ugyanannyi dimenzióval rendelkezzen, mint a bemenet, beállíthatja a keepdims = Trueértéket.

(Ez akkor is működik, ha a axis paramétert használja … próbálja ki!)

Gyakran Ismételt Kérdések a Numpy szórásról

most, hogy megismerte a numpy szórást, és látott néhány példát, nézzük át néhány gyakran ismételt kérdést az np-ről.std.

Gyakran Ismételt Kérdések:

• miért ad a numpy std() más eredményt, mint a matlab std() vagy egy másik programozási nyelv?

1. kérdés: miért ad a numpy std() más eredményt, mint a matlab std() vagy egy másik programozási nyelv?

az egyszerű ok az, hogy a MATLAB a standard dev-et a következők szerint számítja ki:

(sok más eszköz ugyanazt az egyenletet használja.)

a Numpy azonban a következőkkel számol:

vegye figyelembe a a .

ennek kijavításához használhatja a ddof paramétert a Numpy-ban.

Ha np-t használ.std addof paraméter beállításaddof = 1, ugyanazt a választ kell kapnia, mint a matlab.

hagyja más kérdéseit az alábbi megjegyzésekben

van más kérdése a numpy szórás funkcióval kapcsolatban?

hagyja kérdését az alábbi megjegyzések részben.

csatlakozzon a tanfolyamunkhoz, hogy többet megtudjon a Numpy-ról

Az ebben az oktatóanyagban látott példáknak elegendőnek kell lenniük a kezdéshez, de ha komolyan gondolja a numpy tanulását, akkor jelentkezzen be a numpy Mastery nevű prémium tanfolyamunkra.

még sok mindent meg kell tanulni a Numpy-ról, és a numpy Mastery mindent megtanít, beleértve:

• Hogyan hozzunk létre Numpy tömböket
• hogyan használjuk a numpy random függvényeket
• mit csinál a “numpy random seed” függvény
• Hogyan alakítsuk át, osszuk fel és kombináljuk a numpy tömböket
• és így tovább …

ezenkívül néhány héten belül segít teljesen elsajátítani a szintaxist. Megtudhatja, hogyan válhat “folyékonyan” a Numpy kód írásában.

Tudjon meg többet itt:

Tudjon meg többet a Numpy Mastery-ről