Phenquestions
A PyTorch-nak néhány nagy előnye van számítási csomagként, mint például:
- Számítási grafikonokat lehet építeni menet közben. Ez azt jelenti, hogy nem szükséges előre tudni a grafikon memóriaigényét. Szabadon létrehozhatunk egy neurális hálózatot és értékelhetjük azt futás közben.
- Könnyen Python API, amely könnyen integrálható
- A Facebook támogatja, így a közösségi támogatás nagyon erős
- Natív módon nyújt több GPU támogatást
A PyTorchot főként a Data Science közösség veszi át, mivel képes neurális hálózatokat kényelmesen meghatározni. Lássuk ezt a számítási csomagot működés közben ebben a leckében.
A PyTorch telepítése
Csak egy megjegyzés, mielőtt elkezdené, használhat virtuális környezetet ehhez a leckéhez, amelyet a következő paranccsal készíthetünk:
python -m virtualenv pytorchforrás pytorch / bin / aktiválás
Miután a virtuális környezet aktív, telepítheti a PyTorch könyvtárat a virtuális env-be, hogy a következő módon létrehozott példák végrehajthatók legyenek:
pip install pytorchEbben a leckében felhasználjuk az Anacondát és a Jupytert. Ha telepíteni szeretné a számítógépére, nézze meg a „Hogyan telepítsük az Anaconda Python-ot az Ubuntu 18-ra” című leckét.04 LTS ”, és ossza meg visszajelzését, ha bármilyen problémába ütközik. A PyTorch Anaconda alkalmazással történő telepítéséhez használja a következő parancsot az Anaconda termináljában:
conda install -c pytorch pytorchValami ilyesmit látunk, amikor végrehajtjuk a fenti parancsot:
Miután az összes szükséges csomagot telepítette és elkészítette, elkezdhetjük a PyTorch könyvtár használatát a következő importálási utasítással:
import fáklyaKezdjük a PyTorch alapvető példáival, miután telepítettük az előfeltételek csomagjait.
A PyTorch használatának megkezdése
Mivel tudjuk, hogy a neurális hálózatok alapvetően strukturálhatók, mivel a Tensors és a PyTorch a tenzorok köré épül, a teljesítmény jelentősen növekszik. Kezdjük a PyTorch használatával, ha először megvizsgáljuk az általa nyújtott Tensors típusát. A kezdéshez importálja a szükséges csomagokat:
import fáklyaEzután meghatározhatunk egy inicializálatlan Tensort egy meghatározott méretűvel:
x = fáklya.üres (4, 4)nyomtatás ("tömb típusa: ".formátum (x.típus)) # típus
nyomtatás ("tömb alakja: ".formátum (x.alakja)) # alakja
nyomtatás (x)
Valami ilyesmit látunk, amikor a fenti parancsfájlt végrehajtjuk:
Most készítettünk egy inicializálatlan Tensort, amelynek a fenti szkriptben meghatározott mérete volt. Megismételni a Tensorflow leckénkből, a tenzorokat n-dimenziós tömbnek nevezhetjük amely lehetővé teszi az adatok komplex dimenziókban való ábrázolását.
Futtassunk egy másik példát, ahol inicializálunk egy Torched tenzort véletlenszerű értékekkel:
random_tensor = fáklya.rand (5, 4)nyomtatás (random_tensor)
A fenti kód futtatásakor egy véletlenszerű tenzor objektumot fogunk kinyomtatni:
Felhívjuk figyelmét, hogy a fenti véletlenszerű tenzor kimenete eltérő lehet az Ön számára, mert ez véletlenszerű !
Konvertálás a NumPy és a PyTorch között
A NumPy és a PyTorch teljesen kompatibilisek egymással. Ezért könnyű a NumPy tömböket tenzorokká alakítani és fordítva. Az API nyújtotta könnyedségen kívül valószínűleg könnyebb vizualizálni a tenzorokat NumPy tömbök formájában Tensors helyett, vagy csak a NumPy iránti szeretetemnek nevezni!
Például importáljuk a NumPy-t a szkriptünkbe, és meghatározunk egy egyszerű véletlen tömböt:
importálja a numpy-t np-kénttömb = np.véletlen.rand (4, 3)
átalakított_tenzor = fáklya.from_numpy (tömb)
nyomtatás (" \ n".formátum (átalakított_tensor))
A fenti kód futtatásakor az átalakított tenzorobjektumot kinyomtatjuk:
Most próbáljuk meg ezt a tenzort átalakítani NumPy tömbgé:
numpy_arr = transformed_tensor.numpy ()nyomtatás (" \ n".formátum (típus (numpy_arr), numpy_arr))
Amikor futtatjuk a fenti kódot, látni fogjuk az átalakított NumPy tömb kinyomtatását:
Ha jól megnézzük, akkor még a konverzió pontossága is megmarad, miközben a tömböt tenzorrá konvertáljuk, majd visszaállítjuk NumPy tömbgé.
Tenzorműveletek
Mielőtt elkezdenénk a neurális hálózatok körüli vitánkat, ismernünk kell azokat a műveleteket, amelyek a neuronok képzése közben elvégezhetők a tenzorokon. Széles körben fogjuk használni a NumPy modult is.
Tenzor szeletelése
Már megvizsgáltuk, hogyan lehet új Tensort készíteni, készítsünk egyet most és szelet azt:
vektor = fáklya.tenzor ([1, 2, 3, 4, 5, 6])nyomtatás (vektor [1: 4])
A fenti kódrészlet a következő kimenetet biztosítja számunkra:
tenzor ([2, 3, 4])Figyelmen kívül hagyhatjuk az utolsó indexet:
nyomtatás (vektor [1:])És a Python-listával is vissza fogjuk kapni a várhatóakat:
tenzor ([2, 3, 4, 5, 6])Úszó tenzor készítése
Készítsünk most egy úszó tenzort:
úszó_vektor = fáklya.FloatTensor ([1, 2, 3, 4, 5, 6])nyomtatás (float_vector)
A fenti kódrészlet a következő kimenetet biztosítja számunkra:
tenzor ([1., 2., 3., 4., 5., 6.])A tenzor típusa a következő lesz:
print (float_vector.dtype)Visszaadja:
fáklya.úszó32Számtani műveletek a tenzorokon
Két tenzort felvehetünk, akárcsak bármely matematikai elemet, például:
tenzor_1 = fáklya.tenzor ([2, 3, 4])tenzor_2 = fáklya.tenzor ([3, 4, 5])
tenzor_1 + tenzor_2
A fenti kódrészlet megadja:
Tudunk szaporodnak skalárral rendelkező tenzor:
tenzor_1 * 5Ez megadja nekünk:
Végezhetünk egy dot termék két tenzor között is:
d_termék = fáklya.pont (tensor_1, tensor_2)d_termék
A fenti kódrészlet a következő kimenetet biztosítja számunkra:
A következő részben a tenzorok és a mátrixok magasabb dimenzióit vizsgáljuk.
Mátrix szorzás
Ebben a szakaszban meglátjuk, hogyan definiálhatjuk a mutatókat tenzorokként és megsokszorozhatjuk, akárcsak a középiskolai matematikában.
Meghatározunk egy mátrixot a kezdethez:
mátrix = fáklya.tenzor ([1, 3, 5, 6, 8, 0]).nézet (2, 3)A fenti kódrészletben meghatároztunk egy mátrixot a tenzor függvénnyel, majd megadtuk a gombbal nézet funkció hogy 2 dimenziós tenzorként kell elkészíteni 2 sorral és 3 oszloppal. További érvekkel szolgálhatunk a Kilátás függvény további dimenziók megadásához. Csak vegye figyelembe, hogy:
sorszám szorozva oszlopszám = elemszámAmikor a fenti kétdimenziós tenzort vizualizáljuk, a következő mátrixot fogjuk látni:
Meghatározunk egy másik azonos formájú, különböző alakú mátrixot:
mátrix_b = fáklya.tenzor ([1, 3, 5, 6, 8, 0]).nézet (3, 2)Végre végre tudjuk hajtani a szorzást:
fáklya.matmul (mátrix, mátrix_b)A fenti kódrészlet a következő kimenetet biztosítja számunkra:
Lineáris regresszió PyTorch-szal
A lineáris regresszió egy gépi tanulási algoritmus, amely felügyelt tanulási technikákon alapszik a regresszióelemzés elvégzésére független és függő változón. Már zavart? Határozzuk meg a lineáris regressziót egyszerű szavakkal.
A lineáris regresszió egy olyan technika, amellyel kiderülhet két változó kapcsolata, és megjósolható, hogy a független változó mekkora változása mekkora változást okoz a függő változóban. Például lineáris regressziós algoritmus alkalmazható annak megállapítására, hogy egy ház mennyi árnövekedést mutat, ha annak területe megnő egy bizonyos értékkel. Vagy mennyi lóerő van jelen egy autóban a motor súlya alapján. A 2. példa furcsán hangozhat, de mindig megpróbálhat furcsa dolgokat, és ki tudja, hogy a lineáris regresszióval kapcsolatot tud létrehozni ezek között a paraméterek között!
A lineáris regressziós technika általában egy vonal egyenletét használja a függő változó (y) és a független változó (x) közötti kapcsolat ábrázolására:
y = m * x + cA fenti egyenletben:
- m = görbe meredeksége
- c = torzítás (az y tengelyt metsző pont)
Most, hogy van egy egyenletünk, amely a felhasználási esetünk kapcsolatát reprezentálja, megpróbálunk néhány mintaadatot felállítani egy diagram ábrázolással együtt. Itt található a mintaár a házárakhoz és azok méretéhez:
ház_árak = [3, 4, 5, 6, 7, 8, 9]ház_ár_np = np.tömb (house_prices_array, dtype = np.úszó32)
house_price_np = house_price_np.átalakítás (-1,1)
house_price_tensor = Változó (fáklya.from_numpy (house_price_np))
ház_méret = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
ház_méret_np = np.tömb (house_size, dtype = np.úszó32)
ház_méret_np = ház_méret_np.alakítsa át (-1, 1)
house_size_tensor = Változó (fáklya.from_numpy (house_size_np))
# lehetővé teszi az adatok vizualizálását
import matplotlib.pyplot mint plt
plt.szórás (house_prices_array, house_size_np)
plt.xlabel ("Ház ára $")
plt.ylabel ("Házméretek")
plt.cím ("Ház ára $ VS ház mérete")
plt
Ne feledje, hogy a Matplotlib-et használtuk, amely kiváló vizualizációs könyvtár. További információ a Matplotlib bemutatóban található. A fenti kódrészlet futtatása után a következő diagramdiagramot fogjuk látni:
Amikor egy vonalat készítünk a pontokon keresztül, lehet, hogy nem lesz tökéletes, de mégis elegendő a változók közötti kapcsolathoz. Most, hogy összegyűjtöttük és vizualizáltuk adatainkat, meg akarjuk jósolni, hogy mekkora lesz a ház, ha 650 000 dollárért adják el.
A lineáris regresszió alkalmazásának célja egy olyan vonal megtalálása, amely minimális hibával illeszkedik az adatainkhoz. Itt vannak a lineáris regressziós algoritmus alkalmazásához szükséges lépéseket adatainkra:
- Készítsen osztályt a lineáris regresszióhoz
- Határozza meg a modellt ebből a lineáris regressziós osztályból
- Számítsa ki az MSE-t (átlagos négyzethiba)
- Végezze el az optimalizálást a hiba csökkentése érdekében (SGD i.e. sztochasztikus gradiens süllyedés)
- Végezze el a Backpropagation-t
- Végül tegye meg az előrejelzést
Kezdjük a fenti lépések helyes importálásával:
import fáklyafáklyától.autograd import változó
import fáklya.nn mint nn
Ezután meghatározhatjuk a lineáris regressziós osztályunkat, amely a PyTorch neurális hálózati modultól örököl:
osztály LinearRegression (nn.Modul):def __init __ (saját, input_size, output_size):
# szuper funkció örökli az nn-t.Modul, hogy mindent elérhessünk az nn-től.Modul
szuper (LinearRegression, self).__benne__()
# Lineáris függvény
maga.lineáris = nn.Lineáris (input_dim, output_dim)
def előre (én, x):
visszatérő én.lineáris (x)
Most, hogy készen állunk az osztállyal, definiáljuk a modellünket, amelynek bemeneti és kimeneti mérete 1:
input_dim = 1output_dim = 1
model = LinearRegression (input_dim, output_dim)
Meghatározhatjuk az MSE-t:
mse = nn.MSELoss ()Készek vagyunk meghatározni azt az optimalizálást, amely a legjobb előrejelzés alapján elvégezhető a modell előrejelzésén:
# Optimalizálás (keresse meg a hibákat minimalizáló paramétereket)tanulási_ráta = 0.02
optimalizáló = fáklya.optim.SGD (modell.paraméterek (), lr = tanulási arány)
Végül elkészíthetünk egy modellt a veszteségfüggvényhez:
veszteség_lista = []iteráció_száma = 1001
iterációhoz a tartományban (iteráció_szám):
# végezzen optimalizálást nulla gradienssel
optimalizáló.zero_grad ()
eredmények = modell (ház_ár_tensor)
veszteség = mse (eredmények, house_size_tensor)
# derivált kiszámítása hátralépéssel
veszteség.hátrafelé()
# Paraméterek frissítése
optimalizáló.lépés()
# áruház veszteség
veszteség_lista.függelék (veszteség.adat)
# nyomtatási veszteség
ha (iteráció% 50 == 0):
print ('korszak , veszteség '.formátum (iteráció, veszteség.adat))
plt.plot (tartomány (iterációs_szám), veszteség_lista)
plt.xlabel ("Iterációk száma")
plt.ylabel ("veszteség")
plt
Többször optimalizáltuk a veszteségfüggvényt, és megpróbáltuk vizualizálni, hogy mekkora veszteség növekedett vagy csökkent. Itt van a kimenet:
Látjuk, hogy mivel az iterációk száma nagyobb, a veszteség nulla. Ez azt jelenti, hogy készen állunk előrejelzésünk elkészítésére és megtervezésére:
# megjósolni az autó árátmegjósolt = modell (ház_ár_tensor).adat.numpy ()
plt.szétszórás (ház_árak_rajz, ház_méret, címke = "eredeti adatok", szín = "piros")
plt.szórás (ház_árak_array, előrejelzés, label = "előrejelzett adatok", color = "kék")
plt.legenda()
plt.xlabel ("Ház ára $")
plt.ylabel ("Ház mérete")
plt.title ("Eredeti és előre jelzett értékek")
plt.előadás()
Itt van a cselekmény, amely segít megjósolni:
Következtetés
Ebben a leckében egy kiváló számítási csomagot néztünk meg, amely lehetővé teszi számunkra, hogy gyorsabb és hatékonyabb előrejelzéseket készítsünk, és még sok minden mást. A PyTorch azért népszerű, mert lehetővé teszi számunkra, hogy a Tensorokkal alapvető módon kezeljük a neurális hálózatokat.
