V tomto tutoriálu se naučíte, jak použít NumPy reshape() k přetvoření polí NumPy beze změny původních dat.
Při práci s poli Numpy můžete často chtít přetvořit existující pole na pole různých rozměrů. To může být užitečné zejména při transformaci dat ve více krocích.
A NumPy reshape() vám to pomůže snadno. Během několika příštích minut se naučíte syntaxi používat reshape() a také přetvářejte pole na různé rozměry.
Table of Contents
Co je přetvoření v NumPy Arrays?
Při práci s poli NumPy možná budete chtít nejprve vytvořit jednorozměrné pole čísel. A poté jej přetvořte na pole s požadovaným rozměrem.
To je zvláště užitečné, když rozměry nového pole nejsou zpočátku známy nebo jsou odvozeny během provádění. Nebo je také možné, že určitý krok zpracování dat vyžaduje, aby vstup měl specifický tvar.
Zde se přetváření hodí.
Zvažte například následující obrázek. Máme vektor – jednorozměrné pole 6 prvků. A můžeme jej přetvořit na pole tvarů 2×3, 3×2, 6×1 a tak dále.
▶️ Abyste mohli postupovat podle příkladů v tomto tutoriálu, musíte mít nainstalované Python a NumPy. Pokud ještě nemáte NumPy, podívejte se na naši instalační příručku NumPy.
Nyní můžete pokračovat a importovat NumPy pod aliasem np spuštěním: import numpy as np.
Pojďme se naučit syntaxi v další části.
Syntaxe NumPy reshape()
Zde je syntaxe pro použití NumPy reshape():
np.reshape(arr, newshape, order="C"|'F'|'A')
- arr je jakýkoli platný objekt pole NumPy. Zde je to pole, které se má přetvořit.
- newshape je tvar nového pole. Může to být celé číslo nebo n-tice.
- Když je newshape celé číslo, vrácené pole je jednorozměrné.
- pořadí odkazuje na pořadí, ve kterém chcete číst prvky pole, které mají být přetvořeny.
- Výchozí hodnota je ‚C‘, což znamená, že prvky původního pole budou čteny v pořadí indexování podobnému C (počínaje 0)
- ‚F‘ znamená indexování podobné Fortranu (začínající 1). A ‚A‘ čte prvky v pořadí podobném C nebo Fortranu v závislosti na rozložení paměti pole arr.
Co tedy vrací np.reshape()?
Pokud je to možné, vrátí přeformátovaný pohled na původní pole. V opačném případě vrátí kopii pole.
Ve výše uvedeném řádku jsme zmínili, že NumPy reshape() se pokusí vrátit pohled, kdykoli to bude možné. Jinak vrátí kopii. Pojďme diskutovat o rozdílech mezi pohledem a kopií.
Zobrazit vs. kopie polí NumPy
Jak název napovídá, copy je kopie původního pole. A žádné změny provedené v kopii neovlivní původní pole.
Na druhou stranu pohled jednoduše odkazuje na přetvarovaný pohled na původní pole. To znamená, že jakákoli změna provedená v pohledu ovlivní také původní pole a naopak.
Použijte NumPy reshape() k přetvoření 1D pole na 2D pole
#1. Začněme vytvořením vzorového pole pomocí np.arange().
Potřebujeme pole 12 čísel od 1 do 12, nazývané arr1. Protože funkce NumPy arange() ve výchozím nastavení vylučuje koncový bod, nastavte koncovou hodnotu na 13.
Nyní použijme výše uvedenou syntaxi a přetvořme arr1 s 12 prvky do 2D pole tvaru (4,3). Říkejme tomu arr2 se 4 řádky a 3 sloupci.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr2 = np.reshape(arr1,(4,3))
print("nReshaped array:")
print(arr2)
Pojďme se podívat na původní a předělaná pole.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]
Místo předání pole jako argumentu np.reshape() můžete také zavolat metodu .reshape() na původní pole.
Můžete spustit dir(arr1) a zobrazí seznam všech možných metod a atributů, které můžete použít u objektu pole arr1.
dir(arr1) # Output [ ... ... 'reshape' ... .. ]
Ve výše uvedené buňce kódu můžete vidět, že .reshape() je platná metoda pro použití na existujícím poli NumPy arr1.
▶️ Takže můžete také použít následující zjednodušenou syntaxi k přetvoření polí NumPy.
arr.reshape(d0,d1,...,dn) # where: # d0, d1,..,dn are the dimensions of the reshaped array # d0 * d1 * ...* dn = N, the number of elements in arr
Pro zbytek tohoto tutoriálu použijme tuto syntaxi v našich příkladech.
#2. Zkusme přetvořit náš 12prvkový vektor na pole 12 x 1.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr3 = arr1.reshape(12,1)
print("nReshaped array:")
print(arr3)
Ve výstupu níže můžete vidět, že pole bylo podle potřeby přepracováno.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1] [ 2] [ 3] [ 4] [ 5] [ 6] [ 7] [ 8] [ 9] [10] [11] [12]]
❔ Jak tedy zkontrolujeme, zda jsme získali kopii nebo pohled?
Chcete-li to zkontrolovat, můžete zavolat základní atribut na vráceném poli.
- Pokud je pole kopií, základní atribut bude None.
- Pokud je pole zobrazení, základní atribut bude původní pole.
Pojďme si to rychle ověřit.
arr3.base # Output array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
Jak můžete vidět, základní atribut arr3 vrací původní pole. To znamená, že jsme obdrželi pohled na původní pole.
#3. Nyní zkusme přetvořit vektor na jiné platné pole 2 x 6.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr4 = arr1.reshape(2,6)
print("nReshaped array:")
print(arr4)
A tady je výstup:
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1 2 3 4 5 6] [ 7 8 9 10 11 12]]
V další části přetvoříme arr1 na 3D pole.
Použijte NumPy reshape() k přetvoření 1D pole na 3D pole
Chcete-li přetvořit arr1 na 3D pole, nastavte požadované rozměry na (1, 4, 3).
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr3D = arr1.reshape(1,4,3)
print("nReshaped array:")
print(arr3D)
Nyní jsme vytvořili 3D pole se stejnými 12 prvky jako původní pole arr1.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]]
Jak ladit chyby hodnoty během přetváření
Pokud si pamatujete syntaxi, změna tvaru je platná pouze tehdy, když se součin rozměrů rovná počtu prvků v poli.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr2D = arr1.reshape(4,4)
print("nReshaped array:")
print(arr2D)
Zde se pokoušíte přetvořit pole 12 prvků na pole 4×4 se 16 prvky. Interpret vyvolá chybu hodnoty, jak je vidět níže.
Original array, before reshaping:
[ 1 2 3 4 5 6 7 8 9 10 11 12]
-----------------------------------------------------------
ValueError
Traceback (most recent call last)
<ipython-input-11-63552bcc8c37> in <module>()
6
7 # Reshape array
----> 8 arr2 = arr1.reshape(4,4)
9 print("nReshaped array:")
10 print(arr2)
ValueError: cannot reshape array of size 12 into shape (4,4)
Abyste se vyhnuli takovým chybám, můžete použít -1 k automatickému odvození tvaru pro jednu z dimenzí – na základě celkového počtu prvků.
Pokud například předem znáte n – 1 rozměrů, můžete použít -1 k odvození n-tého rozměru v přetvarovaném poli.
Pokud máte 24prvkové pole a chtěli byste jej přetvořit na 3D pole. Předpokládejme, že potřebujete 3 řádky a 4 sloupce. Podél třetího rozměru můžete předat hodnotu -1.
import numpy as np
arr1 = np.arange(1,25)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr_res = arr1.reshape(4,3,-1)
print("nReshaped array:")
print(arr_res)
print(f"Shape of arr_res:{arr_res.shape}")
Když prozkoumáte tvar pole tvarů, můžete vidět, že přetvarované pole má tvar 2 podél třetího rozměru.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24] Reshaped array: [[[ 1 2] [ 3 4] [ 5 6]] [[ 7 8] [ 9 10] [11 12]] [[13 14] [15 16] [17 18]] [[19 20] [21 22] [23 24]]] Shape of arr_res:(4, 3, 2)
To je zvláště užitečné při zploštění pole. A o tom se dozvíte v další části.
Použijte NumPy reshape() ke sloučení pole
Jsou chvíle, kdy byste se museli vrátit z N-rozměrných polí ke zploštělému poli. Předpokládejme, že chcete sloučit obrázek do dlouhého vektoru pixelů.
Pojďme kódovat jednoduchý příklad pomocí následujících kroků:
- Vygenerujte pole obrázků ve stupních šedi 3 x 3, img_arr – s pixely v rozsahu 0 až 255.
- Dále srovnejte tento img_arr a vytiskněte zploštělé pole flat_arr.
- Pro ověření si také vytiskněte tvary img_arr a flat_arr.
img_arr = np.random.randint(0, 255, (3,3))
print(img_arr)
print(f"Shape of img_arr: {img_arr.shape}")
flat_arr = img_arr.reshape(-1)
print(flat_arr)
print(f"Shape of flat_arr: {flat_arr.shape}")
Zde je výstup.
[[195 145 77] [ 63 193 223] [215 43 36]] Shape of img_arr: (3, 3) [195 145 77 63 193 223 215 43 36] Shape of flat_arr: (9,)
Ve výše uvedené buňce kódu můžete vidět, že flat_arr je 1D vektor hodnot pixelů s 9 prvky.
Shrnutí👩🏫
Je čas rychle zopakovat, co jsme se naučili.
- Použijte np.reshape(arr, newshape) k přetvoření arr do tvaru určeného v newshape. newshape je n-tice určující rozměry přetvarovaného pole.
- Alternativně použijte arr.reshape(d0, d1, …, dn) k přetvoření arr tak, aby měl tvar d0 x d1 x … x dn
- Zkontrolujte, zda d0 * d1 * …* dn = N, počet prvků v původním poli, abyste předešli chybám hodnot při přetváření.
- Pokud chcete, aby byla kóta odvozena automaticky, použijte -1 pro maximálně jeden rozměr v novém tvaru.
- Nakonec můžete použít arr.reshape(-1) ke sloučení pole.
Nyní, když víte, jak používat NumPy reshape(), zjistěte, jak funguje funkce NumPy linspace().
Pokud chcete, můžete si vyzkoušet příklady kódu v notebooku Jupyter. Pokud hledáte další vývojová prostředí, podívejte se na naši příručku o alternativách Jupyter.