PyTorch-handledning med linjär regression

PyTorch är ett Python-baserat vetenskapligt paket som ger en ersättning av NumPy ndarrays som Tensorer som tar största möjliga nytta av GPU: erna. En annan positiv punkt om PyTorch-ramverket är den hastighet och flexibilitet som den ger under datorer. PyTorch är ett effektivt alternativ för att arbeta med Tensors med Tensorflow som vi studerade tidigare.

PyTorch har få stora fördelar som ett beräkningspaket, till exempel:

Det är möjligt att bygga beräkningsdiagram när vi går. Detta betyder att det inte är nödvändigt att veta i förväg om minneskraven i diagrammet. Vi kan fritt skapa ett neuralt nätverk och utvärdera det under körning.
Lätt att Python API som är lätt att integrera
Stöds av Facebook, så samhällsstödet är mycket starkt
Tillhandahåller multi-GPU-stöd inbyggt

PyTorch omfamnas huvudsakligen av datavetenskapssamhället på grund av dess förmåga att enkelt definiera neurala nätverk. Låt oss se detta beräkningspaket i aktion i den här lektionen.

Installera PyTorch

Bara en anteckning innan du börjar kan du använda en virtuell miljö för den här lektionen som vi kan göra med följande kommando:

python -m virtualenv pytorch
källa pytorch / bin / aktivera

När den virtuella miljön är aktiv kan du installera PyTorch-biblioteket i det virtuella env så att exempel vi skapar nästa kan köras:

pip installera pytorch

Vi kommer att använda Anaconda och Jupyter i den här lektionen. Om du vill installera den på din maskin, titta på lektionen som beskriver ”Hur man installerar Anaconda Python på Ubuntu 18.04 LTS ”och dela din feedback om du står inför några problem. För att installera PyTorch med Anaconda, använd följande kommando i terminalen från Anaconda:

conda install -c pytorch pytorch

Vi ser något liknande när vi utför ovanstående kommando:

När alla paket som behövs är installerade och klara kan vi komma igång med att använda PyTorch-biblioteket med följande importuttalande:

importera fackla

Låt oss komma igång med grundläggande PyTorch-exempel nu när vi har förutsättningspaket installerat.

Komma igång med PyTorch

Eftersom vi vet att neurala nätverk i grunden kan struktureras eftersom Tensorer och PyTorch är uppbyggda kring tensorer, tenderar det att bli en betydande ökning i prestanda. Vi kommer igång med PyTorch genom att först undersöka vilken typ av tensorer den tillhandahåller. För att komma igång med detta importerar du nödvändiga paket:

importera fackla

Därefter kan vi definiera en oinitialiserad Tensor med en definierad storlek:

x = fackla.tom (4, 4)
skriva ut ("Array Type: ".format (x.typ)) # typ
tryck ("Array Shape: ".format (x.form)) # form
skriva ut (x)

Vi ser något så här när vi kör ovanstående skript:

Vi skapade precis en oinitialiserad Tensor med en definierad storlek i ovanstående skript. För att upprepa från vår Tensorflow-lektion, tensorer kan betecknas som n-dimensionell matris vilket gör att vi kan representera data i komplexa dimensioner.

Låt oss köra ett annat exempel där vi initialiserar en Torched tensor med slumpmässiga värden:

random_tensor = fackla.rand (5, 4)
skriv ut (random_tensor)

När vi kör koden ovan ser vi ett slumpmässigt tensorobjekt som skrivs ut:

Observera att utgången för ovanstående slumpmässig Tensor kan vara annorlunda för dig eftersom den är slumpmässig !

Konvertering mellan NumPy och PyTorch

NumPy och PyTorch är helt kompatibla med varandra. Det är därför det är lätt att omvandla NumPy-matriser till tensorer och vice versa. Bortsett från det lätthet som API ger, är det förmodligen lättare att visualisera tensorerna i form av NumPy-matriser istället för Tensorer, eller bara kalla det min kärlek till NumPy!

Till exempel importerar vi NumPy till vårt skript och definierar en enkel slumpmässig array:

importera numpy som np
array = np.slumpmässig.rand (4, 3)
transformed_tensor = fackla.from_numpy (array)
skriva ut (" \ n".format (transformerad_tensor))

När vi kör ovanstående kod ser vi det transformerade tensorobjektet skrivs ut:

Låt oss nu försöka konvertera denna tensor tillbaka till en NumPy-array:

numpy_arr = transformerad_tensor.bedövad ()
skriva ut (" \ n".format (typ (numpy_arr), numpy_arr))

När vi kör koden ovan ser vi den transformerade NumPy-arrayen skrivs ut:

Om vi tittar noggrant bibehålls även konverteringens precision medan vi konverterar arrayen till en tensor och sedan konverterar den tillbaka till en NumPy-array.

Tensoroperationer

Innan vi påbörjar vår diskussion kring neurala nätverk bör vi känna till de operationer som kan utföras på Tensors medan vi tränar neurala nätverk. Vi kommer också att använda omfattande NumPy-modulen.

Skivning av en Tensor

Vi har redan tittat på hur man skapar en ny Tensor, låt oss göra en nu och skiva Det:

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

Ovan kodavsnittet ger oss följande utdata:

tensor ([2, 3, 4])

Vi kan ignorera det sista indexet:

skriva ut (vektor [1:])

Och vi får tillbaka vad som förväntas med en Python-lista också:

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

Att göra en flytande Tensor

Låt oss nu skapa en flytande Tensor:

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

Ovan kodavsnittet ger oss följande utdata:

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

Typ av denna Tensor kommer att vara:

skriva ut (float_vector.dtype)

Ger tillbaka:

fackla.float32

Aritmetiska operationer på tensorer

Vi kan lägga till två tensorer precis som alla matematiska element, som:

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

Ovanstående kodavsnitt ger oss:

Vi kan multiplicera en tensor med skalär:

tensor_1 * 5

Detta kommer att ge oss:

Vi kan utföra en punkt produkt mellan två tensorer också:

d_product = fackla.punkt (tensor_1, tensor_2)
d_product

Ovan kodavsnittet ger oss följande utdata:

I nästa avsnitt kommer vi att titta på högre dimension av Tensorer och matriser.

Matrixmultiplikation

I det här avsnittet kommer vi att se hur vi kan definiera mätvärden som tensorer och multiplicera dem, precis som vi brukade göra i gymnasiematematik.

Vi kommer att definiera en matris till att börja med:

matris = fackla.tensor ([1, 3, 5, 6, 8, 0]).vy (2, 3)

I kodavsnittet ovan definierade vi en matris med tensorfunktionen och specificerades sedan med Visa funktion att den ska göras som en 2-dimensionell tensor med 2 rader och 3 kolumner. Vi kan ge fler argument till se funktion för att specificera fler dimensioner. Observera bara att:

radantal multiplicerat med kolumnantal = artikelantal

När vi visualiserar ovanstående tvådimensionella tensor ser vi följande matris:

Vi kommer att definiera en annan identisk matris med en annan form:

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

Vi kan äntligen utföra multiplikationen nu:

fackla.matmul (matris, matris_b)

Ovan kodavsnittet ger oss följande utdata:

Linjär regression med PyTorch

Linjär regression är en maskininlärningsalgoritm baserad på övervakade inlärningstekniker för att utföra regressionsanalys på oberoende och en beroende variabel. Förvirrad redan? Låt oss definiera linjär regression i enkla ord.

Linjär regression är en teknik för att ta reda på sambandet mellan två variabler och förutsäga hur mycket förändring i den oberoende variabeln orsakar hur mycket förändring i den beroende variabeln. Till exempel kan linjär regressionsalgoritm användas för att ta reda på hur mycket prishöjningar för ett hus när dess yta ökas med ett visst värde. Eller hur mycket hästkrafter i en bil som finns baserat på dess motorvikt. Det andra exemplet kan låta konstigt men du kan alltid prova konstiga saker och vem vet att du kan skapa ett förhållande mellan dessa parametrar med linjär regression!

Den linjära regressionstekniken använder vanligtvis ekvationen för en linje för att representera förhållandet mellan den beroende variabeln (y) och den oberoende variabeln (x):

y = m * x + c

I ovanstående ekvation:

m = kurvans lutning
c = bias (punkt som skär y-axeln)

Nu när vi har en ekvation som representerar förhållandet mellan vårt användningsfall, kommer vi att försöka skapa några provdata tillsammans med en plotvisualisering. Här är exempeluppgifterna för huspriser och deras storlekar:

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.omforma (-1,1)
house_price_tensor = Variabel (fackla.from_numpy (house_price_np))
house_size = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.array (house_size, dtype = np.float32)
house_size_np = house_size_np.omforma (-1, 1)
house_size_tensor = Variabel (fackla.from_numpy (house_size_np))
# låter oss visualisera våra data
importera matplotlib.pyplot som plt
plt.spridning (house_prices_array, house_size_np)
plt.xlabel ("Huspris $")
plt.ylabel ("Husstorlekar")
plt.titel ("Huspris $ VS Husstorlek")
plt

Observera att vi använde Matplotlib som är ett utmärkt visualiseringsbibliotek. Läs mer om det i Matplotlib Tutorial. Vi ser följande diagramdiagram när vi kör kodkodet ovan:

När vi gör en linje genom punkterna är det kanske inte perfekt men det räcker ändå till den typ av relation variablerna har. Nu när vi har samlat in och visualiserat våra data vill vi förutsäga att vad som kommer att vara storleken på huset om det såldes för $ 650.000.

Målet med att tillämpa linjär regression är att hitta en linje som passar våra uppgifter med minimalt fel. Här är stegen vi kommer att utföra för att tillämpa den linjära regressionsalgoritmen till våra uppgifter:

Konstruera en klass för linjär regression
Definiera modellen från denna klass för linjär regression
Beräkna MSE (medelkvadratfel)
Utför Optimering för att minska felet (SGD i.e. stokastisk gradient nedstigning)
Utför Backpropagation
Slutligen gör förutsägelsen

Låt oss börja använda ovanstående steg med rätt import:

importera fackla
från facklan.autograd import Variabel
importera fackla.nn som nn

Därefter kan vi definiera vår linjära regressionsklass som ärver från PyTorch-neuronnätverksmodulen:

klass LinearRegression (nn.Modul):
def __init __ (själv, input_size, output_size):
# superfunktion ärver från nn.Modul så att vi kan komma åt allt från nn.Modul
super (LinearRegression, self).__i det__()
# Linjär funktion
själv.linjär = nn.Linjär (input_dim, output_dim)
def framåt (själv, x):
återvänd själv.linjär (x)

Nu när vi är redo med klassen, låt oss definiera vår modell med in- och utmatningsstorlek 1:

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

Vi kan definiera MSE som:

mse = nn.MSELoss ()

Vi är redo att definiera den optimering som kan utföras på modellförutsägelsen för bästa prestanda:

# Optimering (hitta parametrar som minimerar felet)
learning_rate = 0.02
optimizer = fackla.optim.SGD (modell.parametrar (), lr = learning_rate)

Vi kan äntligen göra en plot för förlustfunktionen på vår modell:

loss_list = []
iteration_number = 1001
för iteration inom intervallet (iteration_number):
# utför optimering med noll gradient
optimerare.zero_grad ()
resultat = modell (house_price_tensor)
förlust = mse (resultat, hus_storlek_tensor)
# beräkna derivat genom att gå bakåt
förlust.bakåt()
# Uppdaterar parametrar
optimerare.steg()
# butiksförlust
förlustlista.bifoga (förlust.data)
# utskriftsförlust
if (iteration% 50 == 0):
tryck ('epok , förlust '.format (iteration, förlust.data))
plt.plot (intervall (iteration_number), loss_list)
plt.xlabel ("Antal itterationer")
plt.ylabel ("Loss")
plt

Vi utförde optimeringar flera gånger på förlustfunktionen och försökte visualisera hur mycket förlust som ökade eller minskade. Här är plot som är resultatet:

Vi ser att eftersom antalet iterationer är högre tenderar förlusten till noll. Det betyder att vi är redo att göra vår förutsägelse och plotta den:

# förutsäga vårt bilpris
förutsagt = modell (house_price_tensor).data.bedövad ()
plt.scatter (house_prices_array, house_size, label = "original data", color = "red")
plt.scatter (house_prices_array, predicted, label = "predicted data", color = "blue")
plt.legend()
plt.xlabel ("Huspris $")
plt.ylabel ("Husstorlek")
plt.titel ("Original vs Förutspådda värden")
plt.show()

Här är handlingen som hjälper oss att göra förutsägelser:

Slutsats

I den här lektionen tittade vi på ett utmärkt beräkningspaket som låter oss göra snabbare och effektiva förutsägelser och mycket mer. PyTorch är populärt på grund av hur det tillåter oss att hantera neurala nätverk på ett grundläggande sätt med Tensors.