Výukový program PyTorch s lineárnou regresiou

PyTorch je vedecký balík založený na Pythone, ktorý poskytuje náhradu NumPy ndarrays ako tenzorov, čo maximálne využíva GPU. Ďalším pozitívnym bodom v rámci PyTorch je rýchlosť a flexibilita, ktorú poskytuje počas práce s počítačom. PyTorch je efektívna alternatíva práce s Tensors pomocou Tensorflow, o ktorej sme sa už skôr učili.

PyTorch má ako výpočtový balík niekoľko veľkých výhod, napríklad:

Postupne je možné zostavovať výpočtové grafy. To znamená, že nie je potrebné vopred vedieť o pamäťových požiadavkách grafu. Môžeme voľne vytvoriť neurónovú sieť a vyhodnotiť ju za behu programu.
Jednoduché Python API, ktoré je ľahko integrovateľné
Podporuje Facebook, takže podpora komunity je veľmi silná
Natívne poskytuje podporu viacerých grafických procesorov

Komunitu PyTorch prijíma hlavne komunita dátových vied vďaka svojej schopnosti pohodlne definovať neurónové siete. Pozrime sa na tento výpočtový balík v tejto lekcii.

Inštalácia PyTorch

Len na úvod pred začatím môžete pre túto lekciu použiť virtuálne prostredie, ktoré môžeme vytvoriť pomocou nasledujúceho príkazu:

python -m virtualenv pytorch
zdrojový pytorch / bin / aktivovať

Keď je virtuálne prostredie aktívne, môžete si nainštalovať knižnicu PyTorch do virtuálneho env, aby bolo možné vykonať príklady, ktoré vytvoríme ďalej:

pip nainštaluj pytorch

V tejto lekcii využijeme Anacondu a Jupyter. Ak si ho chcete nainštalovať na svoj počítač, pozrite si lekciu, ktorá popisuje „Ako nainštalovať Anaconda Python na Ubuntu 18.04 LTS ”a podeľte sa o svoje pripomienky, ak narazíte na akýkoľvek problém. Ak chcete nainštalovať PyTorch s Anacondou, použite v termináli z príkazu Anaconda nasledujúci príkaz:

conda install -c pytorch pytorch

Vidíme niečo také, keď vykonáme vyššie uvedený príkaz:

Po nainštalovaní a dokončení všetkých potrebných balíkov môžeme začať používať knižnicu PyTorch s nasledujúcim príkazom na import:

dovozná pochodeň

Začnime so základnými príkladmi PyTorch, keď už máme nainštalované balíky nevyhnutných predpokladov.

Začíname s PyTorch

Pretože vieme, že neurónové siete môžu byť zásadne štruktúrované tak, že tenzory a PyTorch sú postavené na tenzoroch, má tendencia k výraznému zvýšeniu výkonu. S programom PyTorch začneme najskôr preskúmaním typu tenzorov, ktoré poskytuje. Ak chcete začať, importujte požadované balíky:

dovozná pochodeň

Ďalej môžeme definovať neinicializovaný Tenzor s definovanou veľkosťou:

x = pochodeň.prázdne (4, 4)
print ("Typ poľa: ".formát (x.typ)) # typ
print ("Tvar poľa: ".formát (x.tvar)) # tvar
tlačiť (x)

Vidíme niečo také, keď vykonáme vyššie uvedený skript:

Vo vyššie uvedenom skripte sme práve vytvorili neinicializovaný Tensor s definovanou veľkosťou. Zopakujeme to z našej lekcie Tensorflow, tenzory možno označiť ako n-rozmerné pole čo nám umožňuje reprezentovať údaje v zložitých dimenziách.

Uveďme ďalší príklad, kde inicializujeme Torched tensor s náhodnými hodnotami:

random_tensor = pochodeň.rand (5, 4)
print (random_tensor)

Keď spustíme vyššie uvedený kód, uvidíme vytlačený náhodný tenzorový objekt:

Upozorňujeme, že výstup vyššie uvedeného náhodného tenzora sa môže u vás líšiť, pretože je náhodný !

Konverzia medzi NumPy a PyTorch

NumPy a PyTorch sú navzájom úplne kompatibilné. Preto je ľahké transformovať polia NumPy na tenzory a naopak. Okrem ľahkosti, ktorú poskytuje API, je pravdepodobne jednoduchšie vizualizovať tenzory vo forme polí NumPy namiesto Tensors, alebo to jednoducho nazvať moja láska k NumPy!

Napríklad naimportujeme NumPy do nášho skriptu a definujeme jednoduché náhodné pole:

importovať numpy ako np
pole = np.náhodný.rand (4, 3)
transformed_tensor = pochodeň.from_numpy (pole)
print (" \ n".formát (transformovaný_tenzor))

Keď spustíme vyššie uvedený kód, uvidíme vytlačený transformovaný objekt:

Teraz sa pokúsime previesť tento tenzor späť na pole NumPy:

numpy_arr = transformovaný_tenzor.numpy ()
print (" \ n".formát (typ (numpy_arr), numpy_arr))

Keď spustíme vyššie uvedený kód, uvidíme vytlačené transformované pole NumPy:

Ak sa pozrieme pozorne, pri prepočte poľa na tenzor a následnom prepočte späť na pole NumPy sa zachová dokonca aj presnosť prevodu.

Tenzorové operácie

Pred začatím diskusie o neurónových sieťach by sme mali poznať operácie, ktoré je možné vykonať na tenzoroch pri trénovaní neurónových sietí. Taktiež budeme hojne využívať modul NumPy.

Krájanie tenzora

Už sme sa pozreli, ako vyrobiť nový Tensor, urobme si ho teraz a plátok to:

vektor = pochodeň.tenzor ([1, 2, 3, 4, 5, 6])
tlač (vektor [1: 4])

Fragment kódu vyššie nám poskytne nasledujúci výstup:

tenzor ([2, 3, 4])

Posledný index môžeme ignorovať:

tlač (vektor [1:])

A vrátime sa späť k očakávaniu aj pri zozname Pythonu:

tenzor ([2, 3, 4, 5, 6])

Výroba plávajúceho tenzora

Urobme teraz plávajúci tenzor:

float_vector = pochodeň.FloatTensor ([1, 2, 3, 4, 5, 6])
print (float_vector)

Fragment kódu vyššie nám poskytne nasledujúci výstup:

tenzor ([1., 2., 3., 4., 5., 6.])

Typ tohto tenzora bude:

print (float_vector.dtype)

Vracia späť:

fakľa.float32

Aritmetické operácie na tenzoroch

Môžeme pridať dva tenzory rovnako ako akékoľvek matematické prvky, napríklad:

tensor_1 = pochodeň.tenzor ([2, 3, 4])
tensor_2 = pochodeň.tenzor ([3, 4, 5])
tensor_1 + tensor_2

Vyššie uvedený úryvok kódu nám poskytne:

Môžeme znásobiť tenzor so skalárom:

tensor_1 * 5

Získate tým:

Môžeme vykonať a skalárny súčin tiež medzi dvoma tenzormi:

d_product = pochodeň.bodka (tensor_1, tensor_2)
d_produkt

Fragment kódu vyššie nám poskytne nasledujúci výstup:

V ďalšej časti sa pozrieme na vyššiu dimenziu tenzorov a matíc.

Násobenie matíc

V tejto časti uvidíme, ako môžeme definovať metriky ako tenzory a vynásobiť ich, rovnako ako sme to zvykli robiť v matematike na strednej škole.

Definujeme maticu, ktorá bude začínať:

matrica = pochodeň.tenzor ([1, 3, 5, 6, 8, 0]).pohľad (2, 3)

Vo vyššie uvedenom útržku kódu sme definovali maticu s funkciou tensor a potom ju zadali pomocou funkcia pohľadu že by mal byť vyrobený ako 2 dimenzionálny tenzor s 2 radmi a 3 stĺpcami. Môžeme poskytnúť viac argumentov k vyhliadka funkcie na zadanie ďalších rozmerov. Upozorňujeme, že:

počet riadkov vynásobený počtom stĺpcov = počet položiek

Keď si vizualizujeme vyššie uvedený dvojrozmerný tenzor, uvidíme nasledujúcu maticu:

Definujeme ďalšiu identickú maticu s iným tvarom:

matrix_b = pochodeň.tenzor ([1, 3, 5, 6, 8, 0]).pohľad (3, 2)

Násobenie môžeme konečne vykonať teraz:

fakľa.matmul (matrix, matrix_b)

Fragment kódu vyššie nám poskytne nasledujúci výstup:

Lineárna regresia s PyTorch

Lineárna regresia je algoritmus strojového učenia založený na technikách učenia pod dohľadom na vykonávanie regresnej analýzy na nezávislej a závislej premennej. Už zmätený? Definujme lineárnu regresiu jednoduchými slovami.

Lineárna regresia je technika na zisťovanie vzťahov medzi dvoma premennými a predpovedanie toho, koľko zmeny v nezávislej premennej spôsobí, koľko zmien v závislej premennej. Napríklad na zistenie toho, ako veľmi sa zvyšuje cena domu, keď sa jeho plocha zvýši o určitú hodnotu, možno použiť algoritmus lineárnej regresie. Alebo koľko koňských síl v automobile je k dispozícii na základe jeho hmotnosti motora. Druhý príklad môže znieť čudne, ale vždy môžete skúsiť čudné veci a ktovie, či ste pomocou Linear Regression schopní vytvoriť vzťah medzi týmito parametrami!

Technika lineárnej regresie zvyčajne používa rovnicu priamky na vyjadrenie vzťahu medzi závislou premennou (y) a nezávislou premennou (x):

y = m * x + c

Vo vyššie uvedenej rovnici:

m = sklon krivky
c = bias (bod, ktorý pretínajú os y)

Teraz, keď máme rovnicu predstavujúcu vzťah nášho prípadu použitia, pokúsime sa nastaviť niekoľko vzorových údajov spolu s vizualizáciou grafu. Tu sú ukážkové údaje o cenách domov a ich veľkostiach:

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.pole (house_prices_array, dtype = np.float32)
house_price_np = house_price_np.pretvarovať (-1,1)
house_price_tensor = Premenná (pochodeň.from_numpy (house_price_np))
house_size = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.pole (house_size, dtype = np.float32)
house_size_np = house_size_np.pretvarovať (-1, 1)
house_size_tensor = Premenná (pochodeň.from_numpy (house_size_np))
# umožňuje vizualizovať naše údaje
import matplotlib.pyplot ako plt
plt.bodový (house_prices_array, house_size_np)
plt.xlabel („Cena domu $“)
plt.ylabel („Veľkosti domu“)
plt.názov ("Cena domu $ VS Veľkosť domu")
plt

Všimnite si, že sme využili Matplotlib, čo je vynikajúca vizualizačná knižnica. Prečítajte si o tom viac v príručke Matplotlib. Po spustení vyššie uvedeného útržku kódu uvidíme nasledujúci grafový graf:

Keď urobíme čiaru cez body, nemusí to byť dokonalé, ale stále to stačí na druh vzťahu, ktorý majú premenné. Teraz, keď sme zhromaždili a vizualizovali naše údaje, chceme predpovedať, aká bude veľkosť domu, ak by sa predal za 650 000 dolárov.

Cieľom aplikácie lineárnej regresie je nájsť čiaru, ktorá zodpovedá našim údajom s minimálnou chybou. Tu sú kroky, ktoré vykonáme pri aplikácii algoritmu lineárnej regresie k našim údajom:

Zostrojte triedu pre lineárnu regresiu
Definujte model z tejto triedy lineárnej regresie
Vypočítajte MSE (stredná štvorcová chyba)
Vykonajte optimalizáciu na zníženie chyby (SGD i.e. stochastický gradient)
Vykonajte spätné šírenie
Nakoniec urobte predpoveď

Začnime uplatňovať vyššie uvedené kroky so správnymi importmi:

dovozná pochodeň
z fakle.autograd import Premenná
dovozná pochodeň.nn ako nn

Ďalej môžeme definovať našu triedu lineárnej regresie, ktorá dedí z modulu neurónovej siete PyTorch:

trieda LinearRegression (nn.Modul):
def __init __ (self, input_size, output_size):
# super funkcia dedí z nn.Modul, aby sme mali prístup ku všetkému od nn.Modul
super (LinearRegression, self).__init __ ()
# Lineárna funkcia
ja.lineárne = nn.Lineárne (input_dim, output_dim)
def forward (self, x):
vrátiť sa.lineárne (x)

Teraz, keď sme pripravení na triedu, definujme náš model s veľkosťou vstupu a výstupu 1:

input_dim = 1
output_dim = 1
model = LinearRegression (input_dim, output_dim)

MSE môžeme definovať ako:

mse = nn.MSELoss ()

Sme pripravení definovať optimalizáciu, ktorá sa dá vykonať na predikcii modelu pre najlepší výkon:

# Optimalizácia (vyhľadajte parametre, ktoré minimalizujú chyby)
learning_rate = 0.02
optimalizátor = pochodeň.optim.SGD (model.parametre (), lr = rýchlosť učenia)

Konečne môžeme na našom modeli vytvoriť graf funkcie straty:

strata_list = []
iteračné_číslo = 1001
pre iteráciu v rozsahu (iteration_number):
# vykonať optimalizáciu s nulovým gradientom
optimalizátor.zero_grad ()
results = model (house_price_tensor)
loss = mse (results, house_size_tensor)
# vypočítajte deriváciu krokom dozadu
strata.dozadu ()
# Aktualizácia parametrov
optimalizátor.krok ()
# strata obchodu
strata_list.append (strata.údaje)
# strata tlače
if (iterácia% 50 == 0):
tlač ('epocha, strata '.formát (iterácia, strata.údaje))
plt.graf (rozsah (iteračné_číslo), zoznam_strat)
plt.xlabel ("Počet iterácií")
plt.ylabel („Strata“)
plt

Optimalizáciu funkcie straty sme vykonali viackrát a pokúsili sme sa vizualizovať, o koľko sa strata zvýšila alebo znížila. Tu je graf, ktorý je výstupom:

Vidíme, že keď je počet iterácií vyšší, strata má tendenciu k nule. To znamená, že sme pripravení urobiť našu predpoveď a vytvoriť ju:

# predpovedajte cenu nášho auta
predikovaný = model (house_price_tensor).údaje.numpy ()
plt.scatter (house_prices_array, house_size, label = "original data", color = "red")
plt.scatter (house_prices_array, predected, label = "predected data", color = "blue")
plt.legenda ()
plt.xlabel („Cena domu $“)
plt.ylabel („Veľkosť domu“)
plt.nadpis („Pôvodné vs predpokladané hodnoty“)
plt.šou()

Tu je dej, ktorý nám pomôže predpovedať:

Záver

V tejto lekcii sme sa zamerali na vynikajúci výpočtový balík, ktorý nám umožňuje robiť rýchlejšie a efektívnejšie predpovede a oveľa viac. PyTorch je populárny kvôli spôsobu, ktorý nám umožňuje spravovať neurónové siete základným spôsobom s Tensors.