Vodič za PyTorch s linearnom regresijom

PyTorch je znanstveni paket zasnovan na Pythonu koji pruža zamjenu NumPy ndarrays-a kao tenzora koji iskorištava maksimalne prednosti GPU-a. Još jedna pozitivna stvar oko PyTorch okvira je brzina i fleksibilnost koju pruža tijekom računanja. PyTorch je učinkovita alternativa radu s tenzorima pomoću Tensorflowa o kojem smo ranije proučavali.

PyTorch ima nekoliko velikih prednosti kao računski paket, kao što su:

Moguće je graditi računske grafikone kako idemo. To znači da nije potrebno unaprijed znati o memorijskim zahtjevima grafa. Možemo slobodno stvoriti neuronsku mrežu i procijeniti je tijekom izvođenja.
Jednostavan za Python API koji je lako integriran
Podržava Facebook, tako da je podrška zajednice vrlo jaka
Izvorno pruža podršku za više GPU-a

PyTorch je uglavnom prihvaćen od strane Data Science zajednice zbog njegove sposobnosti da prikladno definira neuronske mreže. Pogledajmo ovaj računalni paket na djelu u ovoj lekciji.

Instaliranje PyTorch-a

Samo napomenu prije početka, za ovu lekciju možete koristiti virtualno okruženje koje možemo napraviti slijedećom naredbom:

python -m virtualenv pytorch
izvor pytorch / bin / activate

Nakon što je virtualno okruženje aktivno, možete instalirati PyTorch knjižnicu unutar virtualnog okruženja tako da se mogu izvršavati primjeri koje sljedeći put kreiramo:

pip instalirati pytorch

U ovoj ćemo lekciji koristiti Anacondu i Jupyter. Ako ga želite instalirati na svoj stroj, pogledajte lekciju koja opisuje „Kako instalirati Anaconda Python na Ubuntu 18.04 LTS ”i podijelite svoje povratne informacije ako se suočite s bilo kojim problemom. Da biste instalirali PyTorch s Anacondom, upotrijebite sljedeću naredbu u terminalu iz Anaconde:

conda install -c pytorch pytorch

Otprilike ovako vidimo kad izvršimo gornju naredbu:

Jednom kada su instalirani i gotovi svi potrebni paketi, možemo započeti s korištenjem knjižnice PyTorch sa sljedećim izrazom o uvozu:

uvozna baklja

Krenimo s osnovnim primjerima PyTorcha sada kada imamo instalirane pakete preduvjeta.

Početak rada s PyTorchom

Kao što znamo da neuronske mreže mogu biti temeljno strukturirane jer su tenzori i PyTorch izgrađeni oko tenzora, tendencija je da se značajno povećaju performanse. Započet ćemo s PyTorch-om tako što ćemo prvo ispitati vrstu tenzora koje pruža. Da biste započeli s tim, uvezite potrebne pakete:

uvozna baklja

Dalje, možemo definirati neinicijalizirani tenzor definirane veličine:

x = baklja.prazno (4, 4)
print ("Vrsta polja: ".format (x.vrsta)) # vrsta
print ("Oblik niza: ".format (x.oblik)) # oblik
ispis (x)

Otprilike ovako vidimo kad izvršimo gornju skriptu:

Upravo smo napravili neinicijalizirani tenzor definirane veličine u gornjoj skripti. Da ponovimo našu lekciju o Tensorflowu, tenzori se mogu nazvati n-dimenzionalnim nizom što nam omogućuje prikaz podataka u složenim dimenzijama.

Izvršimo još jedan primjer gdje inicijaliziramo Torched tenzor sa slučajnim vrijednostima:

random_tensor = baklja.rand (5, 4)
ispis (random_tensor)

Kad pokrenemo gornji kod, vidjet ćemo ispisan slučajni tenzorski objekt:

Imajte na umu da izlaz za gornji nasumični tenzor može biti drugačiji za vas jer je on slučajan !

Pretvorba između NumPy i PyTorch

NumPy i PyTorch u potpunosti su međusobno kompatibilni. Zbog toga je NumPy niz lako transformirati u tenzore i obrnuto. Osim jednostavnosti koju pruža API, vjerojatno je lakše vizualizirati tenzore u obliku NumPy nizova umjesto Tenzora, ili to jednostavno nazvati mojom ljubavi prema NumPyu!

Na primjer, uvest ćemo NumPy u našu skriptu i definirati jednostavan slučajni niz:

uvoz numpy kao np
niz = np.slučajno.rand (4, 3)
transformirani_tenzor = baklja.from_numpy (niz)
ispis (" \ n".format (transformirani_tenzor))

Kad pokrenemo gornji kôd, vidjet ćemo otisnuti transformirani objekt tenzora:

Pokušajmo sada pretvoriti ovaj tenzor u NumPy niz:

numpy_arr = transformirani_tenzor.numpy ()
ispis (" \ n".format (vrsta (numpy_arr), numpy_arr))

Kada pokrenemo gornji kod, vidjet ćemo transformirani NumPy niz ispisan:

Ako pažljivo pogledamo, zadržava se čak i preciznost pretvorbe dok se niz pretvara u tenzor, a zatim vraća natrag u niz NumPy.

Operacije tenzora

Prije nego što započnemo raspravu o neuronskim mrežama, trebali bismo znati operacije koje se mogu izvoditi na tenzorima tijekom treninga neuronskih mreža. Iskoristit ćemo i NumPy modul.

Rezanje tenzora

Već smo gledali kako napraviti novi Tensor, napravimo ga sada i kriška to:

vektor = baklja.tenzor ([1, 2, 3, 4, 5, 6])
ispis (vektor [1: 4])

Iznad isječka koda pružit će nam sljedeći izlaz:

tenzor ([2, 3, 4])

Možemo zanemariti posljednji indeks:

ispis (vektor [1:])

I vratit ćemo ono što se očekuje i s popisom Python:

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

Izrada plutajućeg tenzora

Napravimo plutajući tenzor:

float_vector = baklja.FloatTensor ([1, 2, 3, 4, 5, 6])
ispis (float_vector)

Iznad isječka koda pružit će nam sljedeći izlaz:

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

Vrsta ovog tenzora bit će:

ispis (float_vector.dtip)

Vraća:

baklja.float32

Aritmetičke operacije na tenzorima

Možemo dodati dva tenzora poput svih matematičkih elemenata, poput:

tenzor_1 = baklja.tenzor ([2, 3, 4])
tenzor_2 = baklja.tenzor ([3, 4, 5])
tenzor_1 + tenzor_2

Gornji isječak koda pružit će nam:

Možemo pomnožiti tenzor sa skalarom:

tenzor_1 * 5

To će nam dati:

Možemo izvesti a točkasti proizvod između dva tenora:

d_produkt = baklja.točka (tenzor_1, tenzor_2)
d_proizvod

Iznad isječka koda pružit će nam sljedeći izlaz:

U sljedećem ćemo dijelu pogledati višu dimenziju tenzora i matrica.

Množenje matrica

U ovom ćemo odjeljku vidjeti kako metriku možemo definirati kao tenzore i pomnožiti ih, baš kao što smo to radili u srednjoškolskoj matematici.

Za početak ćemo definirati matricu:

matrica = baklja.tenzor ([1, 3, 5, 6, 8, 0]).pogled (2, 3)

U gornjem isječku koda definirali smo matricu s funkcijom tenzora i zatim odredili s funkcija pregleda da ga treba izraditi kao dvodimenzionalni tenzor s 2 reda i 3 stupca. Možemo pružiti više argumenata pogled funkcija za određivanje više dimenzija. Samo imajte na umu da:

broj redaka pomnožen s brojem stupaca = broj predmeta

Kad vizualiziramo gornji dvodimenzionalni tenzor, vidjet ćemo sljedeću matricu:

Definirat ćemo još jednu identičnu matricu različitog oblika:

matrica_b = baklja.tenzor ([1, 3, 5, 6, 8, 0]).pogled (3, 2)

Množenje konačno možemo izvršiti sada:

baklja.matmul (matrica, matrica_b)

Iznad isječka koda pružit će nam sljedeći izlaz:

Linearna regresija s PyTorchom

Linearna regresija algoritam je strojnog učenja zasnovan na nadziranim tehnikama učenja za izvođenje regresijske analize na neovisnoj i neovisnoj varijabli. Zbunjen već? Definirajmo linearnu regresiju jednostavnim riječima.

Linearna regresija je tehnika kojom se može utvrditi odnos između dvije varijable i predvidjeti kolika promjena u neovisnoj varijabli uzrokuje koliku promjenu ima ovisna varijabla. Na primjer, algoritam linearne regresije može se primijeniti kako bi se utvrdilo koliko se cijena povećava za kuću kada se njena površina poveća za određenu vrijednost. Ili, koliko je konjskih snaga prisutno u automobilu na temelju njegove težine motora. Drugi primjer možda zvuči čudno, ali uvijek možete isprobati čudne stvari i tko zna da možete uspostaviti vezu između ovih parametara pomoću Linearne regresije!

Tehnika linearne regresije obično koristi jednadžbu crte za predstavljanje odnosa između ovisne varijable (y) i neovisne varijable (x):

y = m * x + c

U gornjoj jednadžbi:

m = nagib krivulje
c = pristranost (točka koja siječe os y)

Sada kada imamo jednadžbu koja predstavlja odnos našeg slučaja upotrebe, pokušat ćemo postaviti neke uzorke podataka zajedno s vizualizacijom parcele. Evo primjera podataka za cijene kuća i njihove veličine:

niz_cjenica_kuca = [3, 4, 5, 6, 7, 8, 9]
kuća_cjena_np = np.niz (kućna_cena_ niz, dtip = np.float32)
kuća_cjena_np = kuća_cjena_np.preoblikovati (-1,1)
house_price_tensor = Promjenjiva (baklja.from_numpy (kuća_price_np))
veličina_ kuće = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
veličina_ kuće_np = np.niz (veličina_ kuće, dtype = np.float32)
house_size_np = veličina_ kuće_np.preoblikovati (-1, 1)
house_size_tensor = Promjenjiva (baklja.from_numpy (kuća_veličina_np))
# omogućuje vizualizaciju naših podataka
uvoz matplotlib.pyplot kao plt
plt.raspršivanje (kuća_cjenica_ niz, veličina_ kuće_np)
plt.xlabel ("Cijena kuće $")
plt.ylabel ("Veličine kuća")
plt.naslov ("Cijena kuće $ VS veličina kuće")
plt

Imajte na umu da smo koristili Matplotlib koji je izvrsna biblioteka za vizualizaciju. Pročitajte više o tome u Vodiču za Matplotlib. Sljedeći grafikon vidjet ćemo nakon što pokrenemo gornji isječak koda:

Kad napravimo liniju kroz točke, ona možda neće biti savršena, ali svejedno je dovoljna za odnos koji varijable imaju. Sad kad smo prikupili i vizualizirali svoje podatke, želimo prognozirati koja će biti veličina kuće ako se proda za 650.000 američkih dolara.

Cilj primjene linearne regresije je pronaći liniju koja odgovara našim podacima s minimalnom pogreškom. Ovdje su korake koje ćemo izvršiti za primjenu algoritma linearne regresije prema našim podacima:

Napravite razred za Linearnu regresiju
Definirajte model iz ove klase linearne regresije
Izračunajte MSE (srednja kvadratna pogreška)
Izvršite optimizaciju kako biste smanjili pogrešku (SGD i.e. stohastički gradijentni spust)
Izvršite povratno razmnožavanje
Napokon, napravite predviđanje

Počnimo primjenjivati gornje korake s ispravnim uvozom:

uvozna baklja
od baklje.autograd uvoz Promjenjiva
uvozna baklja.nn kao nn

Dalje, možemo definirati našu klasu linearne regresije koja nasljeđuje od PyTorch modula neuronske mreže:

razred LinearRegression (nn.Modul):
def __init __ (self, veličina_ ulaza, veličina_izlaza):
# super funkcija nasljeđuje od nn.Modul tako da možemo pristupiti svemu s nn.Modul
super (Linearna regresija, samo).__u tome__()
# Linearna funkcija
sebe.linearno = nn.Linearno (ulazni_dim, izlazni_dim)
def naprijed (self, x):
vratiti se.linearno (x)

Sad kad smo spremni s klasom, definirajmo svoj model s ulaznom i izlaznom veličinom 1:

ulazni_dim = 1
izlazni_dim = 1
model = Linearna regresija (input_dim, output_dim)

MSE možemo definirati kao:

mse = nn.MSELoss ()

Spremni smo definirati optimizaciju koja se može izvesti na predviđanju modela za najbolje performanse:

# Optimizacija (pronađite parametre koji minimiziraju pogreške)
stopa_učenja = 0.02
optimizator = baklja.opt.SGD (model.parametri (), lr = brzina_učenja)

Napokon možemo napraviti grafikon funkcije gubitka na našem modelu:

popis gubitaka = []
iteracija_broj = 1001
za iteraciju u rasponu (iteracija_broj):
# izvršiti optimizaciju s nula gradijenta
optimizator.zero_grad ()
rezultati = model (kuća_cjena_tenzor)
gubitak = mse (rezultati, veličina_kuće_tenzor)
# izračunajte izvedenicu korakom unatrag
gubitak.unazad()
# Ažuriranje parametara
optimizator.korak()
# gubitak u trgovini
popis gubitaka.dodati (gubitak.podaci)
# gubitak ispisa
if (iteracija% 50 == 0):
print ('epoha , gubitak '.format (iteracija, gubitak.podaci))
plt.grafikon (raspon (broj iteracije), popis gubitaka)
plt.xlabel ("Broj ponavljanja")
plt.ylabel ("Gubitak")
plt

Izvršili smo optimizacije više puta na funkciji gubitka i pokušali vizualizirati koliki se gubitak povećao ili smanjio. Evo grafikona koji je rezultat:

Vidimo da kako je broj ponavljanja veći, gubitak teži nuli. To znači da smo spremni napraviti svoje predviđanje i zacrtati ga:

# predvidite cijenu našeg automobila
predviđeno = model (kuća_cjena_tenzor).podaci.numpy ()
plt.raspršenje (kućna_cena_ niz, veličina_ kuće, oznaka = "izvorni podaci", boja = "crvena")
plt.raspršenje (kućne_cijene_ niz, predviđeno, oznaka = "predviđeni podaci", boja = "plava")
plt.legenda()
plt.xlabel ("Cijena kuće $")
plt.ylabel ("Veličina kuće")
plt.naslov ("Izvorne u odnosu na predviđene vrijednosti")
plt.pokazati()

Evo zapleta koji će nam pomoći u predviđanju:

Zaključak

U ovoj smo lekciji pogledali izvrstan računalni paket koji nam omogućuje brže i učinkovitije predviđanja i još mnogo toga. PyTorch je popularan zbog načina na koji nam omogućuje upravljanje neuronskim mrežama na osnovni način s tenzorima.