„PyTorch“ mokymo programa su tiesine regresija

„PyTorch“ yra „Python“ pagrįstas mokslinis paketas, suteikiantis „NumPy“ ndarrays kaip „Tensors“ pakaitalą, kuris maksimaliai išnaudoja GPU. Kitas teigiamas dalykas apie „PyTorch“ sistemą yra greitis ir lankstumas, kurį ji teikia skaičiuodama. „PyTorch“ yra efektyvi alternatyva dirbant su „Tensors“ naudojant „Tensorflow“, apie kurią mes anksčiau mokėmės.

„PyTorch“ turi keletą didelių pranašumų kaip skaičiavimo paketas, pavyzdžiui:

Einant galima susikurti skaičiavimo grafikus. Tai reiškia, kad nebūtina iš anksto žinoti apie grafiko atminties reikalavimus. Mes galime laisvai sukurti neuronų tinklą ir jį įvertinti vykdymo metu.
Lengva integruoti į „Python“ API
Palaiko „Facebook“, todėl bendruomenės palaikymas yra labai stiprus
Natūraliai teikia kelių GPU palaikymą

„PyTorch“ daugiausia priima duomenų mokslo bendruomenė dėl galimybės patogiai apibrėžti neuroninius tinklus. Pažiūrėkime, kaip šis skaičiavimo paketas veikia šioje pamokoje.

„PyTorch“ diegimas

Prieš pradėdami tik pastabą, galite naudoti virtualią aplinką šioje pamokoje, kurią galime padaryti naudodami šią komandą:

pitonas -m virtualenv pytorch
šaltinis pytorch / bin / aktyvuoti

Kai virtuali aplinka bus aktyvi, galite įdiegti „PyTorch“ biblioteką virtualioje aplinkoje, kad būtų galima vykdyti toliau sukurtus pavyzdžius:

pip įdiegti pytorch

Šioje pamokoje pasinaudosime „Anaconda“ ir „Jupyter“. Jei norite jį įdiegti savo kompiuteryje, peržiūrėkite pamoką, kurioje aprašyta „Kaip įdiegti„ Anaconda Python “į„ Ubuntu 18 “.04 LTS “ir pasidalykite savo atsiliepimais, jei kiltų kokių nors problemų. Norėdami įdiegti „PyTorch“ su „Anaconda“, naudokite šią komandą „Anaconda“ terminale:

conda install -c pytorch pytorch

Mes matome kažką panašaus, kai vykdome pirmiau nurodytą komandą:

Įdiegę ir atlikę visus reikalingus paketus, galime pradėti naudotis „PyTorch“ biblioteka naudodami šį importo pareiškimą:

importo deglas

Pradėkime nuo pagrindinių „PyTorch“ pavyzdžių dabar, kai turime įdiegtus būtinų sąlygų paketus.

Darbo su „PyTorch“ pradžia

Kadangi žinome, kad neuroniniai tinklai gali būti iš esmės struktūrizuoti, nes „Tensors“ ir „PyTorch“ yra pastatyti aplink tenzorus, tai gali gerokai pakelti našumą. Mes pradėsime naudotis „PyTorch“ pirmiausia išnagrinėję jo teikiamų „Tensors“ tipą. Norėdami pradėti nuo to, importuokite reikiamus paketus:

importo deglas

Tada galime apibrėžti neinicijuotą „Tensor“ su apibrėžtu dydžiu:

x = degiklis.tuščias (4, 4)
spausdinti ("Masyvo tipas: ".formatas (x.tipas)) # tipas
spausdinti ("Masyvo forma: ".formatas (x.forma)) # forma
spausdinti (x)

Mes matome kažką panašaus, kai vykdome aukščiau pateiktą scenarijų:

Mes ką tik padarėme neinicijuotą „Tensor“ su apibrėžtu dydžiu aukščiau esančiame scenarijuje. Pakartoti iš mūsų „Tensorflow“ pamokos, tenzoriai gali būti vadinami n matmenų masyvu kuris leidžia mums vaizduoti duomenis sudėtingais aspektais.

Paleiskime kitą pavyzdį, kuriame inicijuojame „Torched“ tenzorių su atsitiktinėmis reikšmėmis:

random_tensor = fakelas.randas (5, 4)
spausdinti (random_tensor)

Paleidus pirmiau nurodytą kodą, pamatysime atspausdintą atsitiktinį tensoriaus objektą:

Atkreipkite dėmesį, kad aukščiau esančio atsitiktinio „Tensor“ išvestis jums gali būti skirtinga, nes ji yra atsitiktinė !

Konversija tarp „NumPy“ ir „PyTorch“

„NumPy“ ir „PyTorch“ yra visiškai suderinami. Štai kodėl „NumPy“ masyvus lengva paversti tenzorais ir atvirkščiai. Be paprasto API teikimo, tikriausiai yra lengviau vizualizuoti tenzorus „NumPy“ masyvų, o ne „Tensors“ pavidalu, arba tiesiog vadinti tai mano meile NumPy!

Pavyzdžiui, importuosime „NumPy“ į savo scenarijų ir apibrėžsime paprastą atsitiktinį masyvą:

importuoti numerį kaip np
masyvas = np.atsitiktinis.randas (4, 3)
transformuotas_tenzorius = fakelas.from_numpy (masyvas)
spausdinti (" \ n".formatas (transformuotas_tensorius))

Vykdydami pirmiau nurodytą kodą, pamatysime atspausdintą transformuotą tensoriaus objektą:

Dabar pabandykime konvertuoti šį tensorių atgal į „NumPy“ masyvą:

numpy_arr = transformuotas_tensorius.numpy ()
spausdinti („ \ n“.formatas (tipas (numpy_arr), numpy_arr))

Paleidus pirmiau nurodytą kodą, pamatysime išspausdintą transformuotą „NumPy“ masyvą:

Jei atidžiai pažvelgsime, net konversijos tikslumas išlaikomas konvertuojant masyvą į tenzorą ir tada konvertuojant jį atgal į „NumPy“ masyvą.

Tensoriaus operacijos

Prieš pradėdami diskusijas apie neuroninius tinklus, turėtume žinoti operacijas, kurias galima atlikti „Tensors“ mokant neuroninius tinklus. Taip pat plačiai naudosime „NumPy“ modulį.

Tensoriaus pjaustymas

Mes jau žiūrėjome, kaip padaryti naują „Tensor“, pagaminkime jį dabar ir griežinėlis tai:

vektorius = deglas.tensorius ([1, 2, 3, 4, 5, 6])
spausdinti (vektorius [1: 4])

Aukščiau pateiktas kodo fragmentas suteiks mums šią išvestį:

tensorius ([2, 3, 4])

Galime nepaisyti paskutinio indekso:

spausdinti (vektorius [1:])

Tai, ko tikimasi, sugrąžinsime ir su „Python“ sąrašu:

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

Plūduriuojančio tenoro gaminimas

Dabar sukurkime plaukiantį „Tensor“:

plūdė_vektorius = fakelas.„FloatTensor“ ([1, 2, 3, 4, 5, 6])
spausdinti (float_vector)

Aukščiau pateiktas kodo fragmentas suteiks mums šią išvestį:

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

Šio „Tensor“ tipas bus:

spausdinti (plūduriuojantis_vektorius.dtype)

Grąžina:

deglas.plūdė32

Tenzorių aritmetinės operacijos

Mes galime pridėti du tenzorus, kaip ir bet kuriuos matematinius elementus, tokius kaip:

tensor_1 = fakelas.tensorius ([2, 3, 4])
tensor_2 = fakelas.tensorius ([3, 4, 5])
tensor_1 + tensor_2

Pirmiau pateiktas kodo fragmentas suteiks mums:

Mes galime padauginti tenzorius su skaliarumi:

tensorius_1 * 5

Tai suteiks mums:

Mes galime atlikti a taškinis produktas tarp dviejų tenzorų:

d_product = fakelas.taškas (tensor_1, tensor_2)
d_produktas

Aukščiau pateiktas kodo fragmentas suteiks mums šią išvestį:

Kitame skyriuje mes apžvelgsime aukštesnius tenzorių ir matricų matmenis.

Matricos daugyba

Šiame skyriuje pamatysime, kaip mes galime apibrėžti metriką kaip įtampą ir ją padauginti, kaip tai darėme vidurinės mokyklos matematikoje.

Apibrėžsime matricą, kurią pradėsime:

matrica = deglas.tensorius ([1, 3, 5, 6, 8, 0]).vaizdas (2, 3)

Aukščiau esančiame kodo fragmente mes apibrėžėme matricą su tenso funkcija ir tada nurodėme peržiūros funkcija kad jis turėtų būti padarytas kaip 2 matmenų tenoras su 2 eilutėmis ir 3 stulpeliais. Mes galime pateikti daugiau argumentų vaizdas funkcija nurodyti daugiau matmenų. Tiesiog atkreipkite dėmesį, kad:

eilučių skaičius padaugintas iš stulpelių skaičiaus = prekių skaičius

Kai vizualizuosime pirmiau minėtą dvimatį tensorių, pamatysime šią matricą:

Apibrėžsime kitą identišką matricą su kita forma:

matrica_b = fakelas.tensorius ([1, 3, 5, 6, 8, 0]).vaizdas (3, 2)

Pagaliau galime dauginti dabar:

deglas.matmul (matrica, matrica_b)

Aukščiau pateiktas kodo fragmentas suteiks mums šią išvestį:

Linijinė regresija su PyTorch

Linijinė regresija yra mašininio mokymosi algoritmas, pagrįstas prižiūrimomis mokymosi technikomis, siekiant atlikti nepriklausomo ir priklausomo kintamojo regresijos analizę. Jau sumišęs? Apibūdinkime tiesinę regresiją paprastais žodžiais.

Linijinė regresija yra technika, skirta išsiaiškinti dviejų kintamųjų ryšį ir numatyti, kiek nepriklausomo kintamojo pokyčiai sukelia priklausomo kintamojo pokyčius. Pavyzdžiui, norint sužinoti, kiek padidėja namo kaina, kai jo plotas padidinamas tam tikra verte, galima pritaikyti tiesinį regresijos algoritmą. Arba, kiek arklio galių automobilyje yra, atsižvelgiant į jo variklio svorį. 2-asis pavyzdys gali skambėti keistai, bet jūs visada galite išbandyti keistus dalykus ir kas žino, kad galite nustatyti šių parametrų ryšį naudodami tiesinę regresiją!

Linijinės regresijos technika paprastai naudoja tiesės lygtį, kad būtų rodomas ryšys tarp priklausomo kintamojo (y) ir nepriklausomo kintamojo (x):

y = m * x + c

Pirmiau pateiktoje lygtyje:

m = kreivės nuolydis
c = šališkumas (taškas, kertantis y ašį)

Dabar, kai turime lygtį, vaizduojantį mūsų naudojimo atvejo santykį, pabandysime nustatyti keletą duomenų pavyzdžių kartu su siužeto vizualizacija. Čia pateikiami pavyzdiniai namų kainų ir jų dydžių duomenys:

namo kainos_array = [3, 4, 5, 6, 7, 8, 9]
namo kaina_np = np.masyvas (namo_kainu_raizda, tipo tipas = np.plūdė32)
name_price_np = house_price_np.pertvarkyti (-1,1)
house_price_tensor = kintamasis (degiklis.from_numpy (house_price_np))
namo dydis = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.masyvas (namo_dydis, tipo tipas = np.plūdė32)
house_size_np = house_size_np.pertvarkyti (-1, 1)
house_size_tensor = kintamasis (degiklis.from_numpy (house_size_np))
# leidžia vizualizuoti mūsų duomenis
importuoti matplotlib.pyplotas kaip plt
plt.išsklaidyti (house_prices_array, house_size_np)
plt.„xlabel“ („Namo kaina $“)
plt.ylabel („Namo dydžiai“)
plt.pavadinimas („Namo kaina $ VS namo dydis“)
plt

Atkreipkite dėmesį, kad mes pasinaudojome „Matplotlib“, kuri yra puiki vizualizacijos biblioteka. Daugiau apie tai skaitykite „Matplotlib Tutorial“. Paleidus pirmiau pateiktą kodo fragmentą, pamatysime šį diagramos diagramą:

Kai mes padarome liniją per taškus, ji gali būti ne tobula, bet vis tiek pakanka santykiui, kurį turi kintamieji. Dabar, kai surinkome ir vizualizavome savo duomenis, norime numatyti, koks bus namo dydis, jei jis būtų parduotas už 650 000 USD.

Taikant tiesinę regresiją siekiama rasti liniją, kuri atitiktų mūsų duomenis su minimalia paklaida. Čia yra veiksmus, kuriuos atliksime taikydami tiesinės regresijos algoritmą į mūsų duomenis:

Sukurkite linijinės regresijos klasę
Apibrėžkite modelį iš šios tiesinės regresijos klasės
Apskaičiuokite MSE (vidutinė kvadrato paklaida)
Atlikite optimizavimą, kad sumažintumėte klaidą (SGD i.e. stochastinis gradientinis nusileidimas)
Atlikite „Backpropagation“
Galiausiai atlikite prognozę

Pradėkime taikyti anksčiau nurodytus veiksmus teisingai importuodami:

importo deglas
nuo deglo.autograd import kintamasis
importo deglas.nn kaip nn

Tada galime apibrėžti savo tiesinės regresijos klasę, kuri paveldima iš PyTorch neuroninio tinklo modulio:

klasė LinearRegression (nn.Modulis):
def __init __ (savarankiškai, įvesties_dydis, išvesties_dydis):
# super funkcija paveldima iš nn.Modulis, kad galėtume pasiekti viską nuo nn.Modulis
super (Linijinė regresija, savaime).__init __ ()
# Linijinė funkcija
savarankiškai.tiesinis = nn.Linijinis (įvesties_dim., Išvesties_dim.)
į priekį (savarankiškai, x):
grąžinti save.tiesinis (x)

Dabar, kai būsime pasirengę su klase, apibrėžkime savo modelį, kurio įvesties ir išvesties dydis yra 1:

įvesties_dim = 1
output_dim = 1
modelis = Linijinė regresija (įvesties_dim., išvesties_dim.)

Mes galime apibrėžti MSE kaip:

mse = nn.MSELoss ()

Esame pasirengę apibrėžti optimizavimą, kurį galima atlikti modelio prognozėje, kad būtų pasiektas geriausias našumas:

# Optimizavimas (raskite parametrus, kurie sumažina klaidą)
mokymosi norma = 0.02
optimizatorius = deglas.optim.SGD (modelis.parametrai (), lr = mokymosi greitis)

Pagaliau pagal savo modelį galime sukurti nuostolių funkcijos schemą:

nuostolių_ sąrašas = []
iteracijos_ skaičius = 1001
iteracijai diapazone (iteracijos_numeris):
# atlikti optimizavimą su nuliniu gradientu
optimizatorius.nulis_gradas ()
rezultatai = modelis (namo_kainio_tempėjas)
nuostolis = mse (rezultatai, namo_dydžio_tensorius)
# apskaičiuokite išvestinę priemonę žengdami atgal
nuostoliai.atgal ()
# Parametrų atnaujinimas
optimizatorius.žingsnis ()
# parduotuvės nuostolis
nuostolių_ sąrašas.pridėti (nuostolis.duomenys)
# spausdinimo praradimas
jei (iteracija% 50 == 0):
spausdinti ('epocha, praradimas '.formatas (iteracija, praradimas.duomenys))
plt.plot (diapazonas (iteracijos_numeris), nuostolių_ sąrašas)
plt.xlabel („Iteracijų skaičius“)
plt.ylabel („Praradimas“)
plt

Mes kelis kartus atlikome nuostolių funkcijos optimizavimą ir bandėme įsivaizduoti, kiek nuostolių padidėjo ar sumažėjo. Čia yra išvestis:

Matome, kad didėjant pakartojimų skaičiui, nuostoliai linkę nulį. Tai reiškia, kad esame pasirengę nuspėti ir suplanuoti:

# nuspėti mūsų automobilio kainą
numatytas = modelis (namo_kainos_tempėjas).duomenis.numpy ()
plt.išsklaidyti (namo kainos_dydis, namo_dydis, etiketė = "pirminiai duomenys", spalva = "raudona")
plt.išsklaidyti (namo kainos_sumažyti, nuspėti, etiketė = "numatomi duomenys", spalva = "mėlyna")
plt.legenda ()
plt.„xlabel“ („Namo kaina $“)
plt.ylabel („Namo dydis“)
plt.pavadinimas („Originalios ir numatomos vertės“)
plt.Rodyti()

Čia yra siužetas, kuris padės mums numatyti:

Išvada

Šioje pamokoje apžvelgėme puikų skaičiavimo paketą, kuris leidžia mums spėti greičiau ir efektyviau ir daug daugiau. „PyTorch“ yra populiarus dėl to, kad tai leidžia mums valdyti neuroninius tinklus pagrindiniu būdu su „Tensors“.