Data Science

Výukový program PyTorch s lineární regresí

Výukový program PyTorch s lineární regresí
PyTorch je vědecký balíček založený na Pythonu, který poskytuje náhradu za NumPy ndarrays jako Tensors, což maximálně využívá GPU. Dalším pozitivním bodem rámce PyTorch je rychlost a flexibilita, kterou poskytuje během výpočtu. PyTorch je efektivní alternativa práce s Tensors pomocí Tensorflow, o kterém jsme studovali dříve.

PyTorch má několik velkých výhod jako výpočetní balíček, například:

PyTorch je obklopen hlavně komunitou Data Science díky své schopnosti pohodlně definovat neuronové sítě. Podívejme se na tento výpočetní balíček v akci v této lekci.

Instalace PyTorch

Jen poznámka před spuštěním, pro tuto lekci můžete použít virtuální prostředí, které můžeme provést pomocí následujícího příkazu:

python -m virtualenv pytorch
zdrojový pytorch / bin / aktivovat

Jakmile je virtuální prostředí aktivní, můžete nainstalovat knihovnu PyTorch do virtuálního prostředí, aby bylo možné provést příklady, které vytvoříme dále:

pip nainstalujte pytorch

V této lekci využijeme Anacondu a Jupytera. Chcete-li jej nainstalovat na svůj počítač, podívejte se na lekci, která popisuje „Jak nainstalovat Anaconda Python na Ubuntu 18.04 LTS ”a sdílejte zpětnou vazbu, pokud narazíte na nějaké problémy. Chcete-li nainstalovat PyTorch s Anacondou, použijte v terminálu z Anacondy následující příkaz:

conda install -c pytorch pytorch

Vidíme něco takového, když provedeme výše uvedený příkaz:

Jakmile jsou všechny potřebné balíčky nainstalovány a hotové, můžeme začít používat knihovnu PyTorch s následujícím příkazem importu:

importovat pochodeň

Pojďme začít se základními příklady PyTorch, když máme nainstalované balíčky předpokladů.

Začínáme s PyTorch

Jelikož víme, že neurální sítě mohou být zásadně strukturovány, protože Tensors a PyTorch jsou postaveny kolem tenzorů, má tendenci významně zvyšovat výkon. Začneme s PyTorch nejprve zkoumáním typu tenzorů, které poskytuje. Chcete-li s tím začít, importujte požadované balíčky:

importovat pochodeň

Dále můžeme definovat neinicializovaný Tenzor s definovanou velikostí:

x = pochodeň.prázdný (4, 4)
print ("Typ pole: ".formát (x.typ)) # typ
print ("Tvar pole: ".formát (x.tvar)) # tvar
tisk (x)

Něco takového vidíme, když provedeme výše uvedený skript:

Právě jsme ve výše uvedeném skriptu vytvořili neinicializovaný Tensor s definovanou velikostí. Zopakovat to z naší lekce Tensorflow, tenzory lze označit jako n-rozměrné pole což nám umožňuje reprezentovat data ve složitých dimenzích.

Pojďme spustit další příklad, kde inicializujeme Torched tensor s náhodnými hodnotami:

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

Když spustíme výše uvedený kód, uvidíme vytištěný náhodný tenzorový objekt:

Pamatujte, že výstup výše uvedeného náhodného Tensoru se může u vás lišit, protože je náhodný !

Konverze mezi NumPy a PyTorch

NumPy a PyTorch jsou navzájem zcela kompatibilní. Proto je snadné transformovat pole NumPy na tenzory a naopak. Kromě toho, že API poskytuje snadnost, je pravděpodobně snazší vizualizovat tenzory ve formě polí NumPy místo Tensors, nebo to prostě nazvat mojí láskou k NumPy!

Například naimportujeme NumPy do našeho skriptu a definujeme jednoduché náhodné pole:

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

Když spustíme výše uvedený kód, uvidíme vytištěný transformovaný tenzorový objekt:

Zkusme nyní převést tento tenzor zpět na pole NumPy:

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

Když spustíme výše uvedený kód, uvidíme vytištěné transformované pole NumPy:

Podíváme-li se pozorně, je zachována i přesnost převodu při převodu pole na tenzor a jeho následném převodu zpět na pole NumPy.

Tenzorové operace

Než zahájíme diskusi o neuronových sítích, měli bychom znát operace, které lze provádět na Tensorech při trénování neuronových sítí. Budeme také hojně využívat modul NumPy.

Krájení tenzoru

Už jsme se podívali, jak vyrobit nový Tensor, udělejme si ho hned teď a plátek to:

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

Fragment kódu výše nám poskytne následující výstup:

tenzor ([2, 3, 4])

Poslední index můžeme ignorovat:

tisk (vektor [1:])

Vrátíme také to, co se očekává se seznamem Pythonu:

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

Vytvoření plovoucího tenzoru

Udělejme nyní plovoucí tenzor:

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

Fragment kódu výše nám poskytne následující výstup:

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

Typ tohoto tenzoru bude:

print (float_vector.dtype)

Vrací zpět:

pochodeň.float32

Aritmetické operace na tenzorech

Můžeme přidat dva tenzory stejně jako všechny matematické prvky, například:

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

Výše uvedený fragment kódu nám poskytne:

Můžeme násobit tenzor se skalárem:

tensor_1 * 5

To nám dá:

Můžeme provést a Tečkovaný produkt také mezi dvěma tenzory:

d_product = pochodeň.tečka (tensor_1, tensor_2)
d_produkt

Fragment kódu výše nám poskytne následující výstup:

V další části se podíváme na vyšší dimenzi tenzorů a matic.

Násobení matic

V této části uvidíme, jak můžeme definovat metriky jako tenzory a znásobit je, stejně jako jsme to dělali ve středoškolské matematice.

Definujeme matici, která začíná:

matice = pochodeň.tenzor ([1, 3, 5, 6, 8, 0]).pohled (2, 3)

Ve výše uvedeném fragmentu kódu jsme definovali matici s funkcí tensor a poté ji zadali pomocí funkce zobrazení že by měl být vytvořen jako dvourozměrný tenzor se 2 řádky a 3 sloupy. Můžeme poskytnout více argumentů Pohled funkce k určení více rozměrů. Jen si všimněte, že:

počet řádků vynásobený počtem sloupců = počet položek

Když si představíme výše uvedený 2-dimenzionální tenzor, uvidíme následující matici:

Definujeme další identickou matici s jiným tvarem:

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

Můžeme konečně provést násobení hned:

pochodeň.matmul (matrix, matrix_b)

Fragment kódu výše nám poskytne následující výstup:

Lineární regrese s PyTorch

Lineární regrese je algoritmus strojového učení založený na technikách supervizního učení k provádění regresní analýzy na nezávislé a závislé proměnné. Již zmatený? Pojďme definovat lineární regrese jednoduchými slovy.

Lineární regrese je technika, jak zjistit vztah mezi dvěma proměnnými a předpovědět, kolik změn v nezávislé proměnné způsobí, kolik změn v závislé proměnné. Například lze použít algoritmus lineární regrese ke zjištění, o kolik se zvýší cena domu, když se jeho plocha zvýší o určitou hodnotu. Nebo kolik koní je v automobilu k dispozici na základě jeho hmotnosti motoru. Druhý příklad může znít divně, ale vždy můžete zkusit divné věci a kdo ví, že jste schopni navázat vztah mezi těmito parametry pomocí lineární regrese!

Technika lineární regrese obvykle používá rovnici přímky k vyjádření vztahu mezi závislou proměnnou (y) a nezávislou proměnnou (x):

y = m * x + c

Ve výše uvedené rovnici:

Nyní, když máme rovnici představující vztah našeho případu použití, pokusíme se nastavit několik ukázkových dat spolu s vizualizací grafu. Zde jsou ukázková data cen domů a jejich velikostí:

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.přetvarovat (-1,1)
house_price_tensor = Proměnná (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.změnit tvar (-1, 1)
house_size_tensor = Proměnná (pochodeň.from_numpy (house_size_np))
# umožňuje vizualizovat naše data
import matplotlib.pyplot jako plt
plt.bodový (house_prices_array, house_size_np)
plt.xlabel („Cena domu $“)
plt.ylabel („House Sizes“)
plt.název ("Cena domu $ VS Velikost domu")
plt

Všimněte si, že jsme využili Matplotlib, což je vynikající vizualizační knihovna. Přečtěte si o tom více v tutoriálu Matplotlib. Po spuštění výše uvedeného fragmentu kódu uvidíme následující graf:

Když uděláme přímku skrz body, nemusí to být dokonalé, ale stále to stačí na druh vztahu, který mají proměnné. Nyní, když jsme shromáždili a vizualizovali naše data, chceme předpovědět, jaká bude velikost domu, pokud by byl prodán za 650 000 $.

Cílem aplikace lineární regrese je najít linii, která odpovídá našim datům s minimální chybou. Tady jsou kroky, které provedeme k použití algoritmu lineární regrese k našim údajům:

  1. Vytvořte třídu pro lineární regrese
  2. Definujte model z této třídy lineární regrese
  3. Výpočet MSE (střední kvadratická chyba)
  4. Proveďte optimalizaci ke snížení chyby (SGD i.E. stochastický gradient)
  5. Proveďte Backpropagation
  6. Nakonec proveďte předpověď

Začněme používat výše uvedené kroky se správnými importy:

importovat pochodeň
z pochodně.autograd import Proměnná
importovat pochodeň.nn jako nn

Dále můžeme definovat naši třídu lineární regrese, která dědí z modulu neuronové sítě PyTorch:

třída LinearRegression (nn.Modul):
def __init __ (self, input_size, output_size):
# super funkce dědí z nn.Modul, abychom měli přístup ke všemu od nn.Modul
super (LinearRegression, self).__init __ ()
# Lineární funkce
já.lineární = nn.Lineární (input_dim, output_dim)
def forward (self, x):
vrátit se.lineární (x)

Nyní, když jsme připraveni na třídu, definujme náš model s velikostí vstupu a výstupu 1:

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

Můžeme definovat MSE jako:

mse = nn.MSELoss ()

Jsme připraveni definovat optimalizaci, kterou lze provést na predikci modelu pro nejlepší výkon:

# Optimalizace (vyhledejte parametry, které minimalizují chyby)
learning_rate = 0.02
optimalizátor = hořák.optim.SGD (model.parametry (), lr = rychlost učení)

Nakonec můžeme na našem modelu vytvořit graf funkce ztráty:

loss_list = []
iterační_číslo = 1001
pro iteraci v rozsahu (iterační_číslo):
# provést optimalizaci s nulovým gradientem
optimalizátor.zero_grad ()
results = model (house_price_tensor)
loss = mse (results, house_size_tensor)
# vypočítat derivaci krokem zpět
ztráta.zpět ()
# Aktualizace parametrů
optimalizátor.krok()
# ztráta obchodu
seznam ztrát.připojit (ztráta.data)
# ztráta tisku
if (iterace% 50 == 0):
tisk ('epocha , ztráta '.formát (iterace, ztráta.data))
plt.plot (rozsah (iterační_číslo), seznam ztrát)
plt.xlabel ("Počet iterací")
plt.ylabel („Ztráta“)
plt

Několikrát jsme provedli optimalizaci funkce ztráty a pokusili jsme se vizualizovat, o kolik se ztráta zvýšila nebo snížila. Zde je graf, který je výstupem:

Vidíme, že jelikož je počet iterací vyšší, ztráta má tendenci k nule. To znamená, že jsme připraveni provést naši předpověď a vykreslit ji:

# předpovídat cenu našeho vozu
predikovaný = model (house_price_tensor).data.numpy ()
plt.scatter (house_prices_array, house_size, label = "original data", color = "red")
plt.scatter (house_prices_array, prediction, label = "predicated data", color = "blue")
plt.legenda()
plt.xlabel („Cena domu $“)
plt.ylabel („Velikost domu“)
plt.title ("Původní vs Předpokládané hodnoty")
plt.ukázat()

Zde je děj, který nám pomůže předpovědět:

Závěr

V této lekci jsme se zaměřili na vynikající výpočetní balíček, který nám umožňuje vytvářet rychlejší a efektivnější předpovědi a mnohem více. PyTorch je populární kvůli způsobu, jakým nám umožňuje spravovat neuronové sítě základním způsobem s Tensors.

Snadno komprimujte a dekomprimujte soubory pomocí Ashampoo ZIP Free pro PC
Ashampoo Zip Free je bezplatný software pro kompresi a dekompresi souborů pro operační systém Windows. Bezplatnou verzi lze v zásadě použít k poskytnu...
Jak extrahovat soubor CAB pomocí nástrojů příkazového řádku v systému Windows 10
V prostředí Windows, KABINA označuje soubory kabinetu - formát archivního souboru pro Microsoft Windows. Formát podporuje kompresi dat a vložené digit...
Jak zakázat vestavěnou podporu systému Windows Zip nebo Cab v systému Windows 10
Windows nabízí funkci komprimace souborů podporou Zip funkčnost. I když je to velmi užitečná funkce, pokud již používáte nějaký nástroj pro kompresi t...