Regressione lineare utilizzando PyTorch

| | | | | | | | | | | | | | | | | | | |

Per prima cosa, dovrai installare PyTorch nel tuo ambiente Python. Il modo più semplice per farlo è — usa lo strumento pip o conda . Visita pytorch.org e installa la versione dell`interprete Python e del gestore di pacchetti che desideri utilizzare.


# Possiamo eseguire questo codice Python su un notebook Jupyter
# per installare automaticamente la versione corretta
# PyTorch.


# http://pytorch.org / dal percorso di importazione del sistema operativo

da wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag

piattaforma = `{} {} - {}` . format (get_abbr_impl (), get_impl_ver (), get_abi_tag ())

acceleratore = `cu80` if percorso.esiste ( `/ opt / bin / nvidia-smi` ) else `cpu`


! pip install - q http: / / download.pytorch.org / whl / {acceleratore} / torcia - 0.3 . 0.post4 - {platform} - linux_x86_64.whl torchvision

Con PyTorch installato, andiamo ora guarda il codice.
Scrivi le due righe sottostanti per importare le funzioni e gli oggetti della libreria richiesti.


import torcia

from torch.autograd import Variabile

Definiamo anche alcuni dati e li assegniamo alle variabili x_data e y_data, come segue:


x_data = Variabile (torch.Tensor ([[ 1.0 ], [ 2.0 ], [ 3.0 ]]))

y_data = Variabile (torch.Tensor ([[ 2.0 ], [ 4.0 ], [ 6.0 ]]))

Qui x_data & #8212; la nostra variabile indipendente e y_data — la nostra variabile dipendente. Questo sarà il nostro set di dati per ora. Successivamente, dobbiamo definire il nostro modello. Ci sono due passaggi principali coinvolti nella definizione del nostro modello. Sono:

  1. Inizializzazione del nostro modello.
  2. Dichiarazione di un passaggio in avanti.

Utilizziamo la classe seguente:

class LinearRegressionModel (torch.nn.Module):


def __ init __ ( self ):

super (LinearRegressionModel, self ) .__ init __()

self . lineare = torch.nn.Linear ( 1 , 1 ) # Un input e un`uscita


def avanti ( self , x):

y_pred = self . lineare (x)

return y_pred

Come puoi vedere, la nostra classe Model è una sottoclasse di torch.nn.module. Inoltre, poiché qui abbiamo solo un input e un output, utilizziamo un modello lineare con una dimensione di input e output di 1.

Successivamente, creiamo un oggetto di questo modello.

# il nostro modello

our_model = LinearRegressionModel ()

Dopodiché scegli un ottimizzatore e criteri di perdita. Qui utilizzeremo l`errore quadratico medio (MSE) come funzione di perdita e la discesa del gradiente stocastico (SGD) come ottimizzatore. Inoltre, fissiamo arbitrariamente il tasso di apprendimento a 0,01.


criterio = torch.nn.MSELoss (size_average = Falso )

ottimizzatore = torch.optim.SGD (our_model.parameters()), lr = 0.01 )

Ora arriviamo alla nostra fase di apprendimento. Eseguiamo le seguenti attività 500 volte durante l`allenamento:

  1. Eseguiamo un trasferimento in tempo reale passando i nostri dati e calcolando il valore y previsto.
  2. Calcola la perdita utilizzando MSE.
  3. Reimposta tutti i gradienti su 0, propaga indietro e quindi aggiorna i pesi.

for epoch in range ( 500 ):


# Forward pass: calcola la y prevista passando

#x al modello

pred_y = our_model (x_data)


# Calcola e perdi stampa

perdita = criterio (pred_y, y_data)


# Zero gradienti, backtrack

# e aggiorna il peso.

optimizer.zero_grad ()

loss.backward()

optimizer.step()

print ( ` epoch {}, loss {} ` . format (epoca, loss.data [ 0 ]))

Dopo aver completato la formazione controlliamo se stiamo ottenendo i risultati corretti utilizzando il modello che abbiamo definito. Quindi controlliamo un valore x_data sconosciuto, in questo caso 4.0.


new_var = Variabile (torch.Tensor ([[[ 4.0 ] ]))

pred_y = our_model ( new_var)

print ( "predict ( dopo l`allenamento) " , 4 , our_model ( nuova_var) .data [ 0 ] [ 0 ])

Se hai seguito correttamente tutti i passaggi, vedrai che per l`immissione 4.0 ottieni un valore molto vicino a 8,0, come mostrato di seguito. Pertanto, il nostro modello apprende essenzialmente la relazione tra input e output senza una programmazione esplicita.

predict (dopo l`addestramento) 4 7.966438293457031

Per riferimento, puoi trovare tutto il codice per questo articolo qui sotto:


import torcia

from torch.autograd import Variabile

x_data = Variabile (torch.Tensor ([[ 1.0 ], [ 2.0 ], [ 3.0 ]]))

y_data = V ariable (torch.Tensor ([[ 2.0 ], [ 4.0 ], [ 6.0 ]]))



classe LinearRegressionModel (torch.nn.Module):


def __ init __ ( self ):

super (LinearRegressionModel, self ) .__ init __()

self . lineare = torch.nn.Linear ( 1 , 1 ) # Un input e un output


def forward ( self , x):

y_pred = self . lineare (x)

return y_pred


# il nostro modello

our_model = LinearRegressionModel()

criterio = torch.nn.MSELoss (size_average = False )

ottimizzatore = torcia.ottim. SGD (our_model.parameters (), lr = 0.01 )


for epoch in range ( 500 ):

# Passaggio in avanti: calcola la y prevista passando

# —Ö per modellare

pred_y = our_model (x_data)


# Calcola e perdi stampa

loss = < codice classe ="plain "> criterio (pred_y, y_data)


# Zero gradienti, back pass,

# e aggiorna il peso.

optimizer.zero_grad()

loss.backward()

optimizer.step()

print ( `epoca {}, perdita {}` . formato (epoca, loss.data [ 0 ]))


new_var = Variabile (torch.Tensor ([[ 4.0 ]]))

pred_y = our_model (new_var)

print ( "predict (dopo l`allenamento)" , 4 , our_model (new_var) .data [ 0 ] [ 0 ])

Collegamenti