PyTorch-opplæring med lineær regresjon

PyTorch er en Python-basert vitenskapelig pakke som gir en erstatning av NumPy-fargestoffer som Tensorer som drar størst fordel av GPUene. Et annet positivt poeng med PyTorch-rammeverket er hastigheten og fleksibiliteten den gir under databehandling. PyTorch er et effektivt alternativ for å jobbe med Tensors ved hjelp av Tensorflow som vi studerte om tidligere.

PyTorch har få store fordeler som en beregningspakke, for eksempel:

Det er mulig å bygge beregningsgrafer mens vi går. Dette betyr at det ikke er nødvendig å vite på forhånd om minnekravene i grafen. Vi kan fritt opprette et nevralt nettverk og evaluere det i løpet av kjøretiden.
Lett å Python API som er lett integrerbar
Støttet av Facebook, så samfunnets støtte er veldig sterk
Tilbyr multi-GPU-støtte naturlig

PyTorch omfavnes hovedsakelig av datavitenskapssamfunnet på grunn av dets evne til å definere nevrale nettverk. La oss se denne beregningspakken i aksjon i denne leksjonen.

Installere PyTorch

Bare et notat før du starter, kan du bruke et virtuelt miljø for denne leksjonen som vi kan lage med følgende kommando:

python -m virtualenv pytorch
kilde pytorch / bin / aktiver

Når det virtuelle miljøet er aktivt, kan du installere PyTorch-biblioteket i det virtuelle miljøet slik at eksempler vi oppretter neste kan utføres:

pip installere pytorch

Vi vil bruke Anaconda og Jupyter i denne leksjonen. Hvis du vil installere den på maskinen din, kan du se på leksjonen som beskriver “Slik installerer du Anaconda Python på Ubuntu 18.04 LTS ”og del din tilbakemelding hvis du har problemer. For å installere PyTorch med Anaconda, bruk følgende kommando i terminalen fra Anaconda:

conda installere -c pytorch pytorch

Vi ser noe slikt når vi utfører kommandoen ovenfor:

Når alle nødvendige pakker er installert og ferdig, kan vi komme i gang med å bruke PyTorch-biblioteket med følgende importuttalelse:

importer fakkel

La oss komme i gang med grunnleggende PyTorch-eksempler nå som forutsetningspakkene er installert.

Komme i gang med PyTorch

Ettersom vi vet at nevrale nettverk kan være fundamentalt strukturert som Tensors og PyTorch er bygget rundt tensorer, har det en tendens til å være betydelig økning i ytelse. Vi kommer i gang med PyTorch ved først å undersøke hvilken type tensorer den gir. For å komme i gang med dette, importer de nødvendige pakkene:

importer fakkel

Deretter kan vi definere en ikke-initialisert Tensor med en definert størrelse:

x = fakkel.tom (4, 4)
utskrift ("Array Type: ".format (x.type)) # type
utskrift ("Array Shape: ".format (x.form)) # form
skriv ut (x)

Vi ser noe slikt når vi utfører skriptet ovenfor:

Vi har nettopp laget en ikke-initialisert Tensor med en definert størrelse i skriptet ovenfor. Å gjenta fra Tensorflow-leksjonen vår, tensorer kan betegnes som n-dimensjonalt array som lar oss representere data i komplekse dimensjoner.

La oss kjøre et annet eksempel der vi initialiserer en Torched tensor med tilfeldige verdier:

random_tensor = fakkel.rand (5, 4)
skriv ut (tilfeldig_tensor)

Når vi kjører ovennevnte kode, ser vi et tilfeldig tensorobjekt skrevet ut:

Vær oppmerksom på at utgangen for ovennevnte tilfeldig Tensor kan være annerledes for deg fordi den er tilfeldig !

Konvertering mellom NumPy og PyTorch

NumPy og PyTorch er helt kompatible med hverandre. Det er derfor det er enkelt å transformere NumPy-matriser til tensorer og omvendt. Bortsett fra den enkle API-en, er det sannsynligvis lettere å visualisere tensorene i form av NumPy arrays i stedet for Tensors, eller bare kalle det min kjærlighet til NumPy!

For et eksempel vil vi importere NumPy til skriptet vårt og definere et enkelt tilfeldig utvalg:

importer nummen som np
matrise = np.tilfeldig.rand (4, 3)
transformed_tensor = fakkel.from_numpy (array)
skriv ut (" \ n".format (transformert_tensor))

Når vi kjører ovennevnte kode, ser vi det transformerte tensorobjektet skrevet ut:

La oss nå prøve å konvertere denne tensoren tilbake til et NumPy-utvalg:

numpy_arr = transformert_tensor.nummen ()
skriv ut (" \ n".format (type (numpy_arr), numpy_arr))

Når vi kjører ovennevnte kode, vil vi se det transformerte NumPy-arrayet skrevet ut:

Hvis vi ser nøye, opprettholdes selv presisjonen til konvertering mens vi konverterer matrisen til en tensor og deretter konverterer den tilbake til en NumPy-matrise.

Tensoroperasjoner

Før vi begynner å diskutere nevrale nettverk, bør vi vite operasjonene som kan utføres på Tensors mens vi trener nevrale nettverk. Vi vil også gjøre omfattende bruk av NumPy-modulen.

Slicing a Tensor

Vi har allerede sett hvordan vi skal lage en ny Tensor, la oss lage en nå og skjære den:

vektor = fakkel.tensor ([1, 2, 3, 4, 5, 6])
utskrift (vektor [1: 4])

Ovenfor kodebiten vil gi oss følgende utdata:

tensor ([2, 3, 4])

Vi kan ignorere den siste indeksen:

skriv ut (vektor [1:])

Og vi vil også få tilbake det som forventes med en Python-liste:

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

Å lage en flytende tensor

La oss nå lage en flytende Tensor:

float_vector = fakkel.FloatTensor ([1, 2, 3, 4, 5, 6])
skriv ut (float_vector)

Ovenfor kodebiten gir oss følgende utdata:

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

Type av denne Tensoren vil være:

skriv ut (float_vector.dtype)

Gir tilbake:

lommelykt.flyte32

Aritmetiske operasjoner på tensorer

Vi kan legge til to tensorer akkurat som alle matematiske elementer, som:

tensor_1 = fakkel.tensor ([2, 3, 4])
tensor_2 = fakkel.tensor ([3, 4, 5])
tensor_1 + tensor_2

Ovennevnte kodebit vil gi oss:

Vi kan multiplisere en tensor med en skalar:

tensor_1 * 5

Dette vil gi oss:

Vi kan utføre en prikkprodukt mellom to tensorer også:

d_product = fakkel.prikk (tensor_1, tensor_2)
d_product

Ovenfor kodebiten vil gi oss følgende utdata:

I neste avsnitt vil vi se på høyere dimensjon av tensorer og matriser.

Matriksmultiplikasjon

I denne delen vil vi se hvordan vi kan definere beregninger som tensorer og multiplisere dem, akkurat som vi pleide å gjøre i videregående matematikk.

Vi vil definere en matrise til å begynne med:

matrise = fakkel.tensor ([1, 3, 5, 6, 8, 0]).utsikt (2, 3)

I kodebiten ovenfor definerte vi en matrise med tensorfunksjonen og spesifiserte deretter med visningsfunksjon at den skal lages som en todimensjonal tensor med 2 rader og 3 kolonner. Vi kan gi flere argumenter til utsikt funksjon for å spesifisere flere dimensjoner. Bare vær oppmerksom på at:

radtall ganget med kolonnetall = varetelling

Når vi visualiserer den to-dimensjonale tensoren ovenfor, vil vi se følgende matrise:

Vi vil definere en annen identisk matrise med en annen form:

matrix_b = fakkel.tensor ([1, 3, 5, 6, 8, 0]).utsikt (3, 2)

Vi kan endelig utføre multiplikasjonen nå:

lommelykt.matmul (matrise, matrise_b)

Ovenfor kodebiten vil gi oss følgende utdata:

Lineær regresjon med PyTorch

Lineær regresjon er en maskinlæringsalgoritme basert på overvåket læringsteknikk for å utføre regresjonsanalyse på uavhengige og en avhengig variabel. Forvirret allerede? La oss definere lineær regresjon med enkle ord.

Lineær regresjon er en teknikk for å finne ut forholdet mellom to variabler og forutsi hvor mye endring i den uavhengige variabelen som forårsaker hvor mye endring i den avhengige variabelen. For eksempel kan lineær regresjonsalgoritme brukes for å finne ut hvor mye prisøkninger for et hus når området økes med en viss verdi. Eller hvor mye hestekrefter i en bil som er tilstede basert på motorvekten. Det andre eksemplet kan høres rart ut, men du kan alltid prøve rare ting, og hvem vet at du er i stand til å etablere et forhold mellom disse parametrene med Lineær regresjon!

Den lineære regresjonsteknikken bruker vanligvis ligningen til en linje for å representere forholdet mellom den avhengige variabelen (y) og den uavhengige variabelen (x):

y = m * x + c

I ovenstående ligning:

m = kurvehelling
c = skjevhet (punkt som krysser y-aksen)

Nå som vi har en ligning som representerer forholdet mellom brukssaken vår, vil vi prøve å sette opp noen eksempeldata sammen med en plotvisualisering. Her er eksempeldataene for boligpriser og størrelser:

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.array (house_prices_array, dtype = np.float32)
house_price_np = house_price_np.omforme (-1,1)
house_price_tensor = Variabel (fakkel.from_numpy (house_price_np))
house_size = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.matrise (husstørrelse, dtype = np.float32)
house_size_np = house_size_np.omforme (-1, 1)
house_size_tensor = Variabel (fakkel.from_numpy (house_size_np))
# lar oss visualisere dataene våre
importer matplotlib.pyplot som plt
plt.spredt (house_prices_array, house_size_np)
plt.xlabel ("Huspris $")
plt.ylabel ("Husstørrelser")
plt.tittel ("Huspris $ VS Husstørrelse")
plt

Merk at vi brukte Matplotlib som er et utmerket visualiseringsbibliotek. Les mer om det i Matplotlib Tutorial. Vi ser følgende grafplott når vi kjører kodebiten ovenfor:

Når vi lager en linje gjennom punktene, er det kanskje ikke perfekt, men det er fortsatt nok til den slags forhold variablene har. Nå som vi har samlet inn og visualisert dataene våre, ønsker vi å forutsi at hva som vil være størrelsen på huset hvis det ble solgt for $ 650.000.

Målet med å bruke lineær regresjon er å finne en linje som passer til våre data med minimal feil. Her er trinnene vi skal utføre for å anvende den lineære regresjonsalgoritmen til våre data:

Konstruer en klasse for lineær regresjon
Definer modellen fra denne linjære regresjonsklassen
Beregn MSE (gjennomsnittlig kvadratfeil)
Utfør optimalisering for å redusere feilen (SGD i.e. stokastisk gradient nedstigning)
Utfør Backpropagation
Til slutt gjør spådommen

La oss begynne å bruke trinnene ovenfor med riktig import:

importer fakkel
fra fakkelen.autograd import Variabel
importer fakkel.nn som nn

Deretter kan vi definere vår lineære regresjonsklasse som arver fra PyTorch nevrale nettverksmodul:

klasse LineærRegresjon (nn.Modul):
def __init __ (selv, input_size, output_size):
# superfunksjon arver fra nn.Modul slik at vi får tilgang til alt fra nn.Modul
super (LinearRegression, self).__i det__()
# Lineær funksjon
selv-.lineær = nn.Lineær (input_dim, output_dim)
def fremover (selv, x):
tilbake selv.lineær (x)

Nå som vi er klare med klassen, la oss definere modellen vår med inngangs- og utgangsstørrelse 1:

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

Vi kan definere MSE som:

mse = nn.MSELoss ()

Vi er klare til å definere optimaliseringen som kan utføres på modellforutsigelsen for best ytelse:

# Optimalisering (finn parametere som minimerer feil)
learning_rate = 0.02
optimizer = fakkel.optim.SGD (modell.parametere (), lr = learning_rate)

Vi kan endelig lage et plott for tapsfunksjonen på vår modell:

loss_list = []
iterasjon_nummer = 1001
for iterasjon innen rekkevidde (iteration_number):
# utfør optimalisering med null gradient
optimizer.zero_grad ()
resultater = modell (house_price_tensor)
tap = mse (resultater, husstørrelse_tensor)
# beregne derivater ved å gå bakover
tap.bakover ()
# Oppdaterer parametere
optimizer.steg()
# butiktap
loss_list.legge til (tap.data)
# utskriftstap
hvis (iterasjon% 50 == 0):
utskrift ('epoke , tap '.format (iterasjon, tap.data))
plt.plot (rekkevidde (iterasjonsnummer), loss_list)
plt.xlabel ("Antall gjentakelser")
plt.ylabel ("Tap")
plt

Vi utførte optimaliseringer flere ganger på tapsfunksjonen og prøvde å visualisere hvor mye tap som økte eller reduserte. Her er plottet som er resultatet:

Vi ser at ettersom antall iterasjoner er høyere, har tapet en tendens til null. Dette betyr at vi er klare til å spå og planlegge det:

# forutsi bilprisen vår
predicted = model (house_price_tensor).data.nummen ()
plt.scatter (house_prices_array, house_size, label = "original data", color = "red")
plt.scatter (house_prices_array, predicted, label = "predicted data", color = "blue")
plt.legende()
plt.xlabel ("Huspris $")
plt.ylabel ("Husstørrelse")
plt.tittel ("Original vs Predicted values")
plt.vise fram()

Her er plottet som vil hjelpe oss med å spå:

Konklusjon

I denne leksjonen så vi på en utmerket beregningspakke som lar oss komme med raskere og effektive spådommer og mye mer. PyTorch er populær på grunn av måten den lar oss administrere nevrale nettverk på en grunnleggende måte med Tensors.