PyTorch apmācība ar lineāro regresiju

PyTorch ir uz Python balstīta zinātniskā pakete, kas nodrošina NumPy ndarrays kā Tensors nomaiņu, kas maksimāli izmanto GPU priekšrocības. Vēl viens pozitīvs aspekts par PyTorch sistēmu ir ātrums un elastīgums, ko tas nodrošina skaitļošanas laikā. PyTorch ir efektīva alternatīva darbam ar Tensors, izmantojot Tensorflow, kuru mēs pētījām iepriekš.

PyTorch kā skaitļošanas paketei ir dažas lielas priekšrocības, piemēram:

Ir iespējams izveidot skaitļošanas grafikus, kad mēs ejam. Tas nozīmē, ka nav nepieciešams iepriekš zināt par grafika atmiņas prasībām. Mēs varam brīvi izveidot neironu tīklu un to izpildes laikā novērtēt.
Viegli Python API, kas ir viegli integrējams
To atbalsta Facebook, tāpēc kopienas atbalsts ir ļoti spēcīgs
Nodrošina multi-GPU atbalstu dabiski

Datu zinātnes kopiena galvenokārt izmanto PyTorch, jo tā spēj ērti noteikt neironu tīklus. Apskatīsim šo skaitļošanas paketi darbībā šajā nodarbībā.

PyTorch instalēšana

Pirms sākat tikai piezīmi, šajā nodarbībā varat izmantot virtuālo vidi, kuru mēs varam izveidot ar šādu komandu:

pitons -m virtualenv pytorch
avots pytorch / bin / aktivizēt

Kad virtuālā vide ir aktīva, varat instalēt PyTorch bibliotēku virtuālajā env, lai varētu izpildīt nākamos veidotos piemērus:

pip instalēt pytorch

Šajā nodarbībā mēs izmantosim Anaconda un Jupyter. Ja vēlaties to instalēt savā datorā, skatiet nodarbību, kurā aprakstīts “Kā instalēt Anaconda Python uz Ubuntu 18.04 LTS ”un dalieties savās atsauksmēs, ja rodas kādas problēmas. Lai instalētu PyTorch ar Anaconda, terminālā no Anaconda izmantojiet šādu komandu:

conda instalēt -c pytorch pytorch

Izpildot iepriekš minēto komandu, mēs redzam kaut ko līdzīgu:

Kad visas nepieciešamās pakotnes ir instalētas un pabeigtas, mēs varam sākt izmantot PyTorch bibliotēkas lietošanu ar šādu importēšanas paziņojumu:

importa lāpa

Sāksim ar pamata PyTorch piemēriem tūlīt, kad esam instalējuši priekšnoteikumu pakotnes.

Darba sākšana ar PyTorch

Tā kā mēs zinām, ka neironu tīklus var būt strukturēti, jo Tensors un PyTorch ir veidoti ap tenzoriem, tiem parasti ir ievērojams veiktspējas pieaugums. Mēs sāksim ar PyTorch, vispirms pārbaudot tā piedāvāto Tensors veidu. Lai sāktu ar to, importējiet nepieciešamos iepakojumus:

importa lāpa

Pēc tam mēs varam definēt neinicializētu tenoru ar noteiktu izmēru:

x = lāpa.tukšs (4, 4)
drukāt ("Masīva tips: ".formāts (x.tips)) # tips
drukāt ("Masīva forma: ".formāts (x.forma)) # forma
drukāt (x)

Mēs redzam kaut ko līdzīgu, izpildot iepriekš minēto skriptu:

Mēs tikko izveidojām neinicializētu Tensoru ar noteiktu izmēru iepriekš minētajā skriptā. Atkārtot no mūsu Tensorflow nodarbības, tenzorus var saukt par n-dimensiju masīvu kas ļauj mums attēlot datus sarežģītās dimensijās.

Izpildīsim vēl vienu piemēru, kur mēs inicializējam degļa tenzoru ar nejaušām vērtībām:

random_tensor = lāpa.rands (5, 4)
drukāt (random_tensor)

Palaidot iepriekš minēto kodu, mēs redzēsim iespiestu nejaušu tenzora objektu:

Lūdzu, ņemiet vērā, ka iepriekš nejaušā tenzora izvade jums var būt atšķirīga, jo labi, tā ir nejauša !

Reklāmguvums starp NumPy un PyTorch

NumPy un PyTorch ir pilnīgi savstarpēji saderīgi. Tāpēc NumPy masīvus ir viegli pārveidot par tenoriem un otrādi. Neatkarīgi no API sniegtās ērtības, iespējams, ir vieglāk vizualizēt tenzorus NumPy masīvu veidā, nevis Tensors, vai vienkārši saukt to par manu mīlestību pret NumPy!

Piemēram, mēs importēsim NumPy mūsu skriptā un definēsim vienkāršu nejaušu masīvu:

importēt numpy kā np
masīvs = np.nejaušs.rands (4, 3)
pārveidots_tensors = lāpa.from_numpy (masīvs)
drukāt (" \ n".formāts (pārveidots_tensors))

Palaidot iepriekš minēto kodu, mēs redzēsim pārveidoto tenzora objektu izdrukātu:

Tagad mēģināsim pārveidot šo tenzoru atpakaļ uz NumPy masīvu:

numpy_arr = pārveidots_tensors.numpy ()
drukāt (" \ n".formāts (tips (numpy_arr), numpy_arr))

Palaidot iepriekš minēto kodu, mēs redzēsim izdrukāto pārveidoto NumPy masīvu:

Ja mēs rūpīgi skatāmies, tiek saglabāta pat pārveidošanas precizitāte, vienlaikus pārveidojot masīvu par tenzoru un pēc tam pārveidojot to atpakaļ uz NumPy masīvu.

Tensora operācijas

Pirms sākam diskusiju par neironu tīkliem, mums jāzina operācijas, kuras var veikt ar Tensors, apmācot neironu tīklus. Mēs plaši izmantosim arī NumPy moduli.

Tensora sagriešana

Mēs jau esam izskatījuši, kā padarīt jaunu Tensoru, izveidosim to tagad un šķēle tas:

vektors = lāpa.tenors ([1, 2, 3, 4, 5, 6])
izdruka (vektors [1: 4])

Virs koda fragmenta mums tiks sniegta šāda izeja:

tenors ([2, 3, 4])

Mēs varam ignorēt pēdējo indeksu:

drukāt (vektors [1:])

Un mēs atgūsim gaidīto arī ar Python sarakstu:

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

Peldoša tenzora izgatavošana

Tagad izveidosim peldošu tenoru:

pludiņš_vektors = lāpa.FloatTensor ([1, 2, 3, 4, 5, 6])
drukāt (pludiņš_vektors)

Virs koda fragmenta mums tiks sniegta šāda izeja:

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

Šī Tensora tips būs:

drukāt (pludiņš_vektors.dtype)

Atdod:

lāpa.pludiņš32

Aritmētiskās operācijas ar tenoriem

Mēs varam pievienot divus tenorus tāpat kā visus matemātiskos elementus, piemēram:

tenzors_1 = lāpa.tenors ([2, 3, 4])
tensor_2 = lāpa.tenors ([3, 4, 5])
tensor_1 + tensor_2

Iepriekš sniegtais koda fragments mums dos:

Mēs varam vairoties tenzors ar skalāru:

tenors_1 * 5

Tas mums dos:

Mēs varam veikt a dot produkts starp diviem tenoriem:

d_product = lāpa.punkts (tensor_1, tensor_2)
d_product

Virs koda fragmenta mums tiks sniegta šāda izeja:

Nākamajā sadaļā mēs aplūkosim tenoru un matricu augstāko dimensiju.

Matricas reizināšana

Šajā sadaļā mēs redzēsim, kā mēs varam definēt metriku kā tenorus un tos reizināt, tāpat kā mēs to darījām vidusskolas matemātikā.

Sākumā mēs definēsim matricu:

matrica = lāpa.tenors ([1, 3, 5, 6, 8, 0]).skats (2, 3)

Iepriekš koda fragmentā mēs definējām matricu ar tenzora funkciju un pēc tam norādījām ar skata funkcija ka to vajadzētu izgatavot kā divdimensiju tenzoru ar 2 rindām un 3 kolonnām. Mēs varam sniegt vairāk argumentu skats funkcija, lai norādītu vairāk izmēru. Vienkārši ņemiet vērā, ka:

rindu skaits reizināts ar kolonnu skaitu = vienumu skaits

Vizualizējot iepriekš minēto divdimensiju tenzoru, mēs redzēsim šādu matricu:

Mēs definēsim vēl vienu identisku matricu ar citu formu:

matrica_b = lāpa.tenors ([1, 3, 5, 6, 8, 0]).skats (3, 2)

Tagad beidzot varam veikt reizināšanu:

lāpa.matmul (matrica, matrica_b)

Virs koda fragmenta mums tiks sniegta šāda izeja:

Lineārā regresija ar PyTorch

Lineārā regresija ir mašīnmācīšanās algoritms, kura pamatā ir uzraudzītas mācīšanās metodes, lai veiktu regresijas analīzi neatkarīgam un atkarīgam mainīgajam. Jau apjucis? Definēsim lineāro regresiju vienkāršiem vārdiem.

Lineārā regresija ir paņēmiens, kā noskaidrot sakarību starp diviem mainīgajiem un paredzēt, cik lielas izmaiņas neatkarīgajā mainīgajā rada, cik lielas izmaiņas atkarīgajā mainīgajā. Piemēram, var izmantot lineārās regresijas algoritmu, lai uzzinātu, cik daudz māja palielinās, ja tās platība tiek palielināta par noteiktu vērtību. Vai arī, cik daudz zirgspēku automašīnā ir, ņemot vērā tā dzinēja svaru. 2. piemērs var izklausīties dīvaini, bet jūs vienmēr varat izmēģināt dīvainas lietas un kas zina, ka jūs varat izveidot saikni starp šiem parametriem, izmantojot lineāro regresiju!

Lineārās regresijas paņēmiens parasti izmanto līnijas vienādojumu, lai attēlotu attiecības starp atkarīgo mainīgo (y) un neatkarīgo mainīgo (x):

y = m * x + c

Iepriekš minētajā vienādojumā:

m = līknes slīpums
c = novirze (punkts, kas krustojas ar y asi)

Tagad, kad mums ir vienādojums, kas attēlo mūsu lietošanas gadījuma attiecības, mēs mēģināsim iestatīt dažus datu paraugus kopā ar zemes gabala vizualizāciju. Šeit ir mājas cenu un to izmēru datu paraugi:

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
mājas cena_np = np.masīvs (house_prices_array, dtype = np.pludiņš32)
house_price_np = house_price_np.pārveidot (-1,1)
house_price_tensor = Mainīgais (lāpa.no_numpy (mājas_cena_np))
house_size = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.masīvs (house_size, dtype = np.pludiņš32)
house_size_np = house_size_np.pārveidot (-1, 1)
house_size_tensor = Mainīgs (lāpa.from_numpy (house_size_np))
# ļauj vizualizēt mūsu datus
importa matplotlib.pyplot kā plt
plt.izkliedēt (house_prices_array, house_size_np)
plt.xlabel ("Mājas cena $")
plt.ylabel ("Mājas izmēri")
plt.nosaukums ("Mājas cena $ VS Mājas lielums")
plt

Ņemiet vērā, ka mēs izmantojām Matplotlib, kas ir lieliska vizualizācijas bibliotēka. Lasiet vairāk par to Matplotlib apmācībā. Kad izpildīsim iepriekš minēto koda fragmentu, mēs redzēsim šādu diagrammas diagrammu:

Kad mēs izveidojam līniju caur punktiem, tā, iespējams, nav perfekta, bet tā joprojām ir pietiekama, lai mainīgajiem būtu attiecība. Tagad, kad esam apkopojuši un vizualizējuši savus datus, mēs vēlamies prognozēt, kāds būs mājas lielums, ja to pārdos par 650 000 USD.

Lineārās regresijas pielietošanas mērķis ir atrast līniju, kas atbilst mūsu datiem ar minimālu kļūdu. Šeit ir soļi, kurus veiksim, lai pielietotu lineārās regresijas algoritmu mūsu datiem:

Kontrolējiet lineārās regresijas klasi
Definējiet modeli no šīs lineārās regresijas klases
Aprēķiniet MSE (vidējā kvadrātiskā kļūda)
Veiciet optimizāciju, lai samazinātu kļūdu (SGD i.e. stohastiskā gradienta nolaišanās)
Veiciet Backpropagation
Visbeidzot, izdariet pareģojumu

Sāksim piemērot iepriekš norādītās darbības ar pareizu importēšanu:

importa lāpa
no lāpas.autograd import Variable
importa lāpa.nn kā nn

Pēc tam mēs varam definēt mūsu lineārās regresijas klasi, kas tiek mantota no PyTorch neironu tīkla moduļa:

klase LinearRegression (nn.Modulis):
def __init __ (self, input_size, output_size):
# superfunkcija tiek mantota no nn.Modulis, lai mēs varētu piekļūt visam, sākot no nn.Modulis
super (LinearRegression, self).__tajā__()
# Lineārā funkcija
pats.lineārs = nn.Lineārs (ievades_dim., Izejas_dim.)
def uz priekšu (pats, x):
atgriezties pats.lineārs (x)

Tagad, kad esam gatavi ar klasi, definēsim savu modeli ar ievades un izvades lielumu 1:

ievades_dimuls = 1
izejas_dimuls = 1
modelis = LinearRegression (input_dim, output_dim)

Mēs varam definēt MSE kā:

mse = nn.MSELoss ()

Mēs esam gatavi noteikt optimizāciju, ko var veikt modeļa prognozē, lai iegūtu vislabāko veiktspēju:

# Optimizācija (atrodiet parametrus, kas samazina kļūdu skaitu)
mācību_noteikums = 0.02
optimizētājs = lāpa.optim.SGD (modelis.parametri (), lr = mācību_likme)

Mēs beidzot varam izveidot diagrammu zaudējumu funkcijai pēc mūsu modeļa:

zaudējumu_ saraksts = []
atkārtojuma_numurs = 1001
iterācijai diapazonā (iterācijas_numurs):
# veikt optimizāciju ar nulles gradientu
optimizētājs.zero_grad ()
rezultāti = modelis (mājas_cenas_tensors)
zaudējums = mse (rezultāti, mājas_izmēra_tensors)
# aprēķināt atvasinājumu, atkāpjoties atpakaļ
zaudējums.atpakaļ ()
# Parametru atjaunināšana
optimizētājs.solis ()
# veikala zaudējumi
loss_list.pievienot (zaudējums.dati)
# drukas zudums
ja (atkārtojums% 50 == 0):
drukāt ('laikmets , zaudējums '.formāts (atkārtojums, zaudējums.dati))
plt.plot (diapazons (iterācijas_numurs), loss_list)
plt.xlabel ("Iterāciju skaits")
plt.ylabel ("Zaudējums")
plt

Mēs vairākas reizes veicām zaudējumu funkcijas optimizāciju un mēģinām vizualizēt, cik zaudējumi palielinājās vai samazinājās. Šeit ir sižets, kas ir rezultāts:

Mēs redzam, ka, tā kā atkārtojumu skaits ir lielāks, zaudējumi mēdz būt nulle. Tas nozīmē, ka mēs esam gatavi izdarīt savu prognozi un to uzzināt:

# paredzēt mūsu automašīnas cenu
prognozētais = modelis (mājas_cenas_tensors).dati.numpy ()
plt.izkliede (house_prices_array, house_size, label = "original data", color = "red")
plt.izkliede (house_prices_array, prognozēts, label = "paredzētie dati", color = "zils")
plt.leģenda ()
plt.xlabel ("Mājas cena $")
plt.ylabel ("Mājas lielums")
plt.nosaukums ("Sākotnējās un paredzētās vērtības")
plt.rādīt ()

Lūk, sižets, kas mums palīdzēs prognozēt:

Secinājums

Šajā nodarbībā mēs apskatījām lielisku aprēķinu paketi, kas ļauj mums veikt ātrākas un efektīvākas prognozes un daudz ko citu. PyTorch ir populārs tāpēc, ka tas ļauj mums pamatīgi pārvaldīt neironu tīklus ar Tensors.