Change language
Python.Engineering Wiki Regresja liniowa przy użyciu PyTorch

Regresja liniowa przy użyciu PyTorch

__del__ | __main__ Python module | ast Python module | code Python module | COM PHP module | exp | GD PHP module | http Python module | imp Python module | io Python module | os Python module | platform Python module | PS PHP module | Python functions | Rar PHP module | re Python module | square | StackOverflow | stat Python module | time Python module | UI PHP module
Michael Zippo Michael Zippo

Najpierw musisz zainstalować PyTorch w swoim środowisku Python. Najprostszym sposobem na to jest — użyj narzędzia pip lub conda . Odwiedź pytorch.org i zainstaluj wersję swojego interpretera Pythona i menedżera pakietów, których chcesz używać.


# Możemy uruchomić ten kod Pythona na notatniku Jupyter
#, aby automatycznie zainstalować poprawną wersję
# PyTorch.


# http://pytorch.org / ze ścieżki importu systemu operacyjnego

z wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag

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

akcelerator = `cu80` if path.exists ( `/ opt / bin / nvidia-smi` ) else `cpu`


! pip install - q http: / / download.pytorch.org / whl / {akcelerator} / latarka - 0,3 . 0.post4 - {platforma} - linux_x86_64.whl torchvision

Po zainstalowaniu PyTorch zajmijmy się teraz spójrz na kod.
Napisz dwa poniższe wiersze, aby zaimportować wymagane funkcje i obiekty biblioteki.


importuj latarka

z torch.autograd import Zmienna

Zdefiniujemy również niektóre dane i przypisujemy je do zmiennych x_data i y_data, w następujący sposób:


x_data = Zmienna (pochodnia.Tensor ([[ 1.0 ], [ 2.0 ], [ 3.0 ]]))

y_data = Zmienna (torch.Tensor ([[ 2,0 ], [ 4.0 ], [ 6.0 ]]))

Tutaj x_data & #8212; nasza zmienna niezależna i y_data — naszą zmienną zależną. To będzie na razie nasz zbiór danych. Następnie musimy zdefiniować nasz model. Definiowanie naszego modelu składa się z dwóch głównych etapów. Są to:

  1. Inicjowanie naszego modelu.
  2. Deklarowanie podania w przód.

Używamy poniższej klasy:

class LinearRegressionModel (torch.nn.Module):


def __ init __ ( self ):

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

self . linear = torch.nn.Linear ( 1 , 1 ) # Jedno wejście i jedno wyjście


def forward ( self , x):

y_pred = self . linear (x)

return y_pred

Jak widać, nasza klasa Model jest podklasą torch.nn.module. Ponadto, ponieważ mamy tutaj tylko jedno wejście i jedno wyjście, używamy modelu liniowego o rozmiarze wejścia i wyjścia równym 1.

Następnie tworzymy obiekt tego modelu.

# nasz model

nasz_model = LinearRegressionModel ()

Następnie wybierz optymalizator i kryteria strat. Tutaj użyjemy błędu średniokwadratowego (MSE) jako funkcji straty i stochastycznego spadku gradientu (SGD) jako naszego optymalizatora. Ustalamy również arbitralnie szybkość uczenia się na 0,01.


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

optymalizator = torch.optim.SGD (our_model.parameters (), lr = 0,01 )

Teraz dochodzimy do etapu nauki. Podczas szkolenia 500 razy wykonujemy następujące zadania:

  1. Wykonaj transfer na żywo, przekazując nasze dane i obliczając przewidywaną wartość y.
  2. Oblicz straty za pomocą MSE.
  3. Zresetuj wszystkie gradienty do 0, propaguj wstecz, a następnie zaktualizuj wagi.

for epoch w zakresie ( 500 ):


# Przejście do przodu: oblicz przewidywane y przez przekazanie

#x do modelu

pred_y = our_model (x_data)


# Oblicz i trać wydruk

strata = kryterium (pred_y, y_data)


# Zero gradientów, cofanie się

# i zaktualizuj wagę.

optimr.zero_grad()

loss.backward ()

Optimizer.step ()

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

Po ukończeniu szkolenia sprawdzamy, czy otrzymujemy poprawne wyniki za pomocą zdefiniowany przez nas model. Sprawdzamy więc, czy nie ma nieznanej wartości x_data, w tym przypadku 4.0.


new_var = Zmienna (latarka.Tensor ([[[ 4.0 ] ]))

pred_y = our_model ( new_var)

print ( "przewiduj (po szkoleniu) " , 4 , nasz_model ( new_var) .data [ 0 ] [ 0 ])

Jeśli poprawnie wykonałeś wszystkie kroki, zobaczysz, że dla wpisu 4.0 otrzymasz wartość bardzo bliska 8,0, jak pokazano poniżej. W ten sposób nasz model zasadniczo uczy się relacji między wejściem a wyjściem bez wyraźnego programowania.

przewiduj (po szkoleniu) 4 7.966438293457031

Dla odniesienia można znaleźć cały kod tego artykułu poniżej:


import latarka

z torch.autograd importuj Zmienna

x_data = Zmienna (torch.Tensor ([[ 1.0 ], [ 2,0 ], [ 3.0 ]]))

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



class LinearRegressionModel (torch.nn.Module):


def __ init __ ( self ):

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

self . linear = torch.nn.Linear ( 1 , 1 ) # Jedno wejście i jedno wyjście


def forward ( self , x):

y_pred = self . linear (x)

return y_pred


# nasz model

nasz_model = LinearRegressionModel ()

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

optymalizator = latarka.optim. SGD (our_model.parameters (), lr = 0,01 )


for epoch in range ( 500 ):

# Przejście do przodu: oblicz przewidywane y przez przekazanie

# —Ö do modelu

pred_y = nasz_model (x_data)


# Oblicz i trać print

loss = < klasa kodu ="plain "> kryterium (pred_y, y_data)


# Zero gradientów, wsteczne podanie,

# i zaktualizuj wagę.

optimer.zero_grad()

loss.backward ()

optimer.step ()

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


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

pred_y = our_model (new_var)

print ( "przewidywanie (po szkoleniu)" , 4 , nasz_model (nowa_zmienna) .data [ 0 ] [ 0 ])

Linki