Lineaarse regressiooniga PyTorchi õpetus

PyTorch on Pythoni põhine teaduspakett, mis pakub NumPy ndarrays kui tenorid asendust, mis kasutab GPU-sid maksimaalselt ära. Teine positiivne punkt PyTorchi raamistiku kohta on arvutuse ajal pakutav kiirus ja paindlikkus. PyTorch on tõhus alternatiiv töötamiseks Tensorsi kasutamisel Tensorflow abil, mida me varem uurisime.

PyTorchil on arvutuspaketina vähe suuri eeliseid, näiteks:

Arvutamisgraafikuid on võimalik üles ehitada, kui käime. See tähendab, et graafiku mälunõuetest pole vaja ette teada. Saame vabalt luua närvivõrgu ja seda tööaja jooksul hinnata.
Lihtne Pythoni API, mis on hõlpsasti integreeritav
Toetab Facebook, seega on kogukonna toetus väga tugev
Pakub mitme GPU tuge loomulikult

Andmeteaduse kogukond võtab PyTorchi peamiselt omaks tänu oma võimele mugavalt määratleda närvivõrke. Vaatame seda arvutuspaketti selles tunnis toimimas.

PyTorchi installimine

Enne alustamist võite lihtsalt märkida, et saate selle õppetunni jaoks kasutada virtuaalset keskkonda, mille saame teha järgmise käsuga:

python -m virtualenv pytorch
allikas pytorch / bin / aktiveeri

Kui virtuaalne keskkond on aktiivne, saate installida PyTorchi teegi virtuaalsesse env-sse, et saaksime järgmiselt loodud näited täita:

pip paigaldage pytorch

Selles tunnis kasutame Anaconda ja Jupyterit. Kui soovite selle oma arvutisse installida, vaadake õppetundi, mis kirjeldab artiklit „Kuidas Anaconda Pythoni installida Ubuntu 18.04 LTS ”ja jagage oma tagasisidet, kui teil on probleeme. PyTorchi installimiseks koos Anacondaga kasutage Anaconda terminalis järgmist käsku:

conda install -c pytorch pytorch

Ülaloleva käsu täitmisel näeme midagi sellist:

Kui kõik vajalikud paketid on installitud ja tehtud, saame alustada PyTorchi teegi kasutamist järgmise impordilausega:

impordi tõrvik

Alustame PyTorchi põhinäidetega kohe, kui eeltingimuste paketid on installitud.

PyTorchiga alustamine

Kuna teame, et närvivõrke saab põhimõtteliselt struktureerida, kuna Tensors ja PyTorch on üles ehitatud tenorite ümber, kipub jõudlust märkimisväärselt suurendama. Alustame PyTorchiga, uurides kõigepealt selle pakutavate tenorite tüüpi. Selle alustamiseks importige vajalikud paketid:

impordi tõrvik

Järgmisena saame määratleda määratlemata suurusega initsialiseerimata tensori:

x = tõrvik.tühi (4, 4)
print ("Massiivi tüüp: ".vorming (x.tüüp)) # tüüp
print ("Massiivi kuju: ".vorming (x.kuju)) # kuju
print (x)

Ülaloleva skripti käivitamisel näeme midagi sellist:

Me lihtsalt tegime algata tensori, mille suurus oli ülaltoodud skriptis määratletud. Meie Tensorflow õppetundist korrata, tenoreid võib nimetada n-mõõtmeliseks massiiviks mis võimaldab meil andmeid esitada keerulistes mõõtmetes.

Käivitame veel ühe näite, kus lähtestame juhuslike väärtustega põletatud tenori:

juhuslik_tensor = tõrvik.rand (5, 4)
print (random_tensor)

Kui käivitame ülaltoodud koodi, näeme juhusliku tensori objekti printimist:

Pange tähele, et ülaltoodud juhusliku Tensori väljund võib teie jaoks olla erinev, sest see on juhuslik !

NumPy ja PyTorchi teisendamine

NumPy ja PyTorch sobivad omavahel täielikult kokku. Seetõttu on NumPy massiive lihtne muuta tensoriteks ja vastupidi. Peale API-le pakutava lihtsuse on tenoreid tõenäoliselt lihtsam visualiseerida Tenorside asemel NumPy massiividena või lihtsalt nimetada seda minu armastuseks NumPy vastu!

Näiteks impordime NumPy oma skripti ja määrame lihtsa juhusliku massiivi:

impordi numpy kui np
massiiv = np.juhuslik.rand (4, 3)
muundatud_tensor = tõrvik.from_numpy (massiiv)
print (" \ n".vorming (transformed_tensor))

Kui käivitame ülaltoodud koodi, näeme teisendatud tensori objekti prindituna:

Proovime nüüd selle tensori teisendada NumPy massiiviks:

numpy_arr = transformeeritud_tensor.numpy ()
print (" \ n".vorming (tüüp (numpy_arr), numpy_arr))

Kui käivitame ülaltoodud koodi, näeme teisendatud NumPy massiivi prindituna:

Kui vaatame tähelepanelikult, säilitatakse isegi teisendamise täpsus, muutes massiivi tenoriks ja teisendades selle seejärel NumPy massiiviks.

Tensori toimingud

Enne kui alustame arutelu närvivõrkude üle, peaksime teadma toiminguid, mida saab teha närvivõrkude koolitamisel Tensoritel. Kasutame laialdaselt ka NumPy moodulit.

Tensori viilutamine

Oleme juba uurinud, kuidas uut Tensorit teha, teeme selle nüüd ja viil see:

vektor = tõrvik.tensor ([1, 2, 3, 4, 5, 6])
print (vektor [1: 4])

Ülal olev koodilõik annab meile järgmise väljundi:

tensor ([2, 3, 4])

Me võime ignoreerida viimast indeksit:

print (vektor [1:])

Ja saame tagasi ka Pythoni loendiga loodetava:

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

Ujuva tensori valmistamine

Teeme nüüd ujuva Tensori:

ujuk_vektor = tõrvik.FloatTensor ([1, 2, 3, 4, 5, 6])
print (float_vector)

Ülal olev koodilõik annab meile järgmise väljundi:

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

Selle tensori tüüp on:

print (float_vector.dtype)

Annab tagasi:

tõrvik.ujuk32

Tensorite aritmeetilised toimingud

Saame lisada kaks tenorit nagu kõik matemaatilised elemendid, näiteks:

tensor_1 = tõrvik.tensor ([2, 3, 4])
tensor_2 = tõrvik.tensor ([3, 4, 5])
tensor_1 + tensor_2

Ülaltoodud koodilõik annab meile:

Me saame korrutada skalaariga tenor:

tensor_1 * 5

See annab meile:

Saame sooritada a täpne toode ka kahe tensori vahel:

d_product = tõrvik.punkt (tensor_1, tensor_2)
d_toode

Ülal olev koodilõik annab meile järgmise väljundi:

Järgmises osas vaatleme tenorite ja maatriksite kõrgemat mõõdet.

Maatriksi korrutamine

Selles jaotises näeme, kuidas me saame mõõdikuid määratleda tenoritena ja korrutada neid, täpselt nagu vanasti keskkooli matemaatikas.

Alustuseks määratleme maatriksi:

maatriks = tõrvik.tensor ([1, 3, 5, 6, 8, 0]).vaade (2, 3)

Ülalolevas koodilõigus määratlesime maanduri koos funktsiooniga tensor ja seejärel täpsustasime vaate funktsioon et see tuleks teha kahemõõtmelise 2 rida ja 3 veeruga tensorina. Saame esitada rohkem argumente vaade funktsioon rohkemate mõõtmete määramiseks. Pange tähele, et:

ridade arv korrutatuna veergude arvuga = üksuste arv

Kui visualiseerime ülaltoodud kahemõõtmelise tenori, näeme järgmist maatriksit:

Määratleme veel ühe identse ja erineva kujuga maatriksi:

maatriks_b = tõrvik.tensor ([1, 3, 5, 6, 8, 0]).vaade (3, 2)

Lõpuks saame korrutamise nüüd teha:

tõrvik.matmul (maatriks, maatriks_b)

Ülal olev koodilõik annab meile järgmise väljundi:

Lineaarne regressioon PyTorchiga

Lineaarne regressioon on masinõppe algoritm, mis põhineb juhendatud õppetehnikatel regressioonianalüüsi teostamiseks sõltumatul ja sõltuval muutujal. Segaduses juba? Määratleme lineaarne regressioon lihtsate sõnadega.

Lineaarne regressioon on meetod kahe muutuja vahelise seose väljaselgitamiseks ja selle ennustamiseks, kui palju sõltumatu muutuja muutus põhjustab sõltuva muutuja muutusi. Näiteks saab kasutada lineaarse regressiooni algoritmi, et teada saada, kui palju maja hind tõuseb, kui selle pindala suureneb teatud väärtuse võrra. Või siis, kui palju hobuses on autos mootori kaalu põhjal. Teine näide võib tunduda imelik, kuid võite alati proovida imelikke asju ja kes teab, et saate nende parameetrite vahelise seose luua lineaarse regressiooniga!

Lineaarse regressiooni tehnikas kasutatakse joone võrrandit sõltuva muutuja (y) ja sõltumatu muutuja (x) vahelise suhte esitamiseks:

y = m * x + c

Ülaltoodud võrrandis:

m = kõvera kalle
c = eelarvamus (punkt, mis lõikub y-teljega)

Nüüd, kui meil on võrrand, mis esindab meie kasutusjuhtumi suhet, proovime koos proovitüki visualiseerimisega seadistada mõned näidisandmed. Siin on majahindade ja nende suuruste näidisandmed:

majahindade arhiiv [3, 4, 5, 6, 7, 8, 9]
majahind_np = np.massiiv (maja_hinnad_rae, dtype = np.float32)
majahind_np = majahind_np.ümber kujundama (-1,1)
house_price_tensor = Muutuv (tõrvik.alates_numpy (maja_hind_np))
maja_suurus = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
maja_suuruse_np = np.massiiv (maja_suurus, dtüüp = np.float32)
maja_suuruse_np = maja_suuruse_np.ümber kujundama (-1, 1)
house_size_tensor = Muutuv (tõrvik.from_numpy (maja_suuruse_np))
# laseb meie andmeid visualiseerida
import matplotlib.püplot nagu plt
plt.hajumine (maja_hinnad_rae, maja_suuruse_np)
plt.xlabel ("Maja hind $")
plt.ylabel ("Maja suurused")
plt.pealkiri ("Maja hind $ VS maja suurus")
plt

Pange tähele, et kasutasime Matplotlibi, mis on suurepärane visualiseerimise teek. Lisateavet selle kohta leiate Matplotlibi õpetusest. Pärast ülaltoodud koodilõigu käivitamist näeme järgmist graafiku graafikut:

Kui teeme punktide kaudu joone, ei pruugi see olla täiuslik, kuid see on siiski piisav muutujate vahelise seose jaoks. Nüüd, kui oleme oma andmed kogunud ja visualiseerinud, tahame ennustada, et kui suur on maja suurus, kui see müüdi 650 000 dollari eest.

Lineaarse regressiooni rakendamise eesmärk on leida joon, mis sobib meie andmetele minimaalse veaga. Siin on sammud, mille teeme lineaarse regressiooni algoritmi rakendamiseks meie andmetele:

Ehitage klass lineaarse regressiooni jaoks
Määratlege selle lineaarse regressiooni klassi mudel
Arvutage MSE (keskmine ruutviga)
Tehke vea vähendamiseks optimeerimine (SGD i.e. stohhastiline gradientne laskumine)
Tehke Backpropagation
Lõpuks tehke ennustus

Alustame ülaltoodud samme õige impordiga:

impordi tõrvik
tõrvikust.autogradi import Muutuja
impordi tõrvik.nn nagu nn

Järgmisena saame määratleda meie lineaarse regressiooni klassi, mis pärineb PyTorchi närvivõrgu moodulist:

klass LinearRegression (nn.Moodul):
def __init __ (ise, sisendi_suurus, väljundsuurus):
# superfunktsioon pärib nn-st.Moodul, et saaksime kõigele juurde pääseda nn.Moodul
super (lineaarne regressioon, ise).__selles__()
# Lineaarne funktsioon
ise.lineaarne = nn.Lineaarne (sisendi_dim, väljund_dim)
def edasi (ise, x):
tagasi ise.lineaarne (x)

Nüüd, kui oleme klassiga valmis, määratleme oma mudeli sisendi ja väljundi suurusega 1:

sisendi_dim = 1
väljunddim = 1
mudel = LinearRegression (sisendi_dim, väljund_dim)

MSE saab määratleda järgmiselt:

mse = nn.MSELoss ()

Oleme valmis määrama optimeerimise, mida saab mudeli prognoosimisel parima jõudluse saavutamiseks:

# Optimeerimine (leidke parameetrid, mis minimeerivad tõrkeid)
õppimise_hind = 0.02
optimeerija = tõrvik.optimaalne.SGD (mudel.parameetrid (), lr = õppemäär

Lõpuks saame oma mudeli järgi koostada kaotusfunktsiooni kavandi:

kaotuse_loend = []
iteratsiooni_arv = 1001
iteratsiooni vahemikus (iteratsiooni_arv):
# optimeerimine nullgradientiga
optimeerija.null_grad ()
tulemused = mudel (maja_hinna_tensor)
kaotus = mse (tulemused, house_size_tensor)
# arvutage tuletis tagasi astudes
kaotus.tagasi ()
# Parameetrite värskendamine
optimeerija.samm ()
# poe kahjum
kaotuse_loend.lisama (kadu.andmed)
# prindikadu
kui (iteratsioon% 50 == 0):
print ('ajastu , kadu '.vorming (iteratsioon, kadu.andmed))
plt.joonis (vahemik (iteratsiooni_number), kaotuse_loend)
plt.xlabel ("korduste arv")
plt.ylabel ("Kaotus")
plt

Tegime mitu korda kaotuse funktsiooni optimeerimist ja proovisime visualiseerida, kui palju kahju suurenes või vähenes. Siin on graafik, mis on väljund:

Näeme, et kuna korduste arv on suurem, kipub kaotus nulli. See tähendab, et oleme valmis oma ennustuse tegema ja selle kavandama:

# ennustage meie auto hinda
ennustatud = mudel (maja_hinna_tensor).andmed.numpy ()
plt.hajumine (majahinnad_rae, maja_suurus, silt = "algandmed", värv = "punane")
plt.hajumine (majahinnad_array, ennustatud, silt = "ennustatud andmed", värv = "sinine")
plt.legend()
plt.xlabel ("Maja hind $")
plt.ylabel ("Maja suurus")
plt.pealkiri ("Algsed vs ennustatud väärtused")
plt.näita ()

Siin on süžee, mis aitab meil ennustada:

Järeldus

Selles tunnis vaatasime suurepärast arvutuspaketti, mis võimaldab meil teha kiiremaid ja tõhusamaid ennustusi ning palju muud. PyTorch on populaarne sellepärast, et see võimaldab meil närvivõrke Tensorsiga põhimõtteliselt juhtida.