Change language
Python.Engineering Wiki Lineaire regressie met PyTorch

Lineaire regressie met 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

Eerst moet u PyTorch in uw Python-omgeving installeren. De eenvoudigste manier om dit te doen is — gebruik de tool pip of conda . Ga naar pytorch.org en installeer de versie van uw Python-interpreter en pakketbeheerder die u wilt gebruiken.


# We kunnen deze Python-code uitvoeren op een Jupyter-notebook
# om automatisch de juiste versie te installeren
# PyTorch.


# http://pytorch.org / van os importpad

van wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag

platform = `{} {} - {}` . formaat (get_abbr_impl (), get_impl_ver (), get_abi_tag ())

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


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

Met PyTorch geïnstalleerd, laten we nu kijk naar de code.
Schrijf de twee regels hieronder om de vereiste bibliotheekfuncties en objecten te importeren.


import zaklamp

van torch.autograd importeren Variabele

We definiëren ook enkele gegevens en wijzen deze toe aan de variabelen x_data en y_data, als volgt:


x_data = Variabele (toorts.Tensor ([[ 1.0 ], [ 2.0 ], [ 3.0 ]]))

y_data = Variabele (toorts.Tensor ([[ 2.0 ], [ 4.0 ], [ 6.0 ]]))

Hier x_data & #8212; onze onafhankelijke variabele, en y_data — onze afhankelijke variabele. Dit wordt voorlopig onze dataset. Vervolgens moeten we ons model definiëren. Er zijn twee hoofdstappen bij het definiëren van ons model. Ze zijn:

  1. Ons model initialiseren.
  2. Een voorwaartse pass afkondigen.

We gebruiken de onderstaande klasse:

class LinearRegressionModel (torch.nn.Module):


def __ init __ ( zelf ):

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

zelf . linear = torch.nn.Linear ( 1 , 1 ) # Eén invoer en één uitgang


def vooruit ( zelf , x):

y_pred = zelf . lineair (x)

return y_pred

Zoals je kunt zien, is onze klasse Model een subklasse van torch.nn.module. Omdat we hier slechts één invoer en één uitvoer hebben, gebruiken we bovendien een lineair model met een invoer- en uitvoergrootte van 1.

Vervolgens maken we een object van dit model.

# ons model

ons_model = LinearRegressionModel ()

Kies daarna een optimalisatieprogramma en verlies criteria. Hier zullen we mean squared error (MSE) gebruiken als onze verliesfunctie en Stochastic Gradient Descent (SGD) als onze optimizer. We stellen ook willekeurig de leersnelheid vast op 0,01.


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

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

Nu komen we bij onze leerfase. We voeren de volgende taken 500 keer uit tijdens de training:

  1. Voer een live overdracht uit door onze gegevens door te geven en de voorspelde y-waarde te berekenen.
  2. Bereken verlies met MSE.
  3. Stel alle gradiënten terug op 0, propageer terug en werk de gewichten bij.

voor tijdperk in bereik ( 500 ):


# Forward pass: bereken voorspeld y door

#x naar het model

pred_y = our_model (x_data)


# Bereken en verlies print

verlies = criterium (pred_y, y_data)


# Geen hellingen, terug

# en werk het gewicht bij.

optimizer.zero_grad ()

loss.backward ()

optimizer.step ()

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

Na het voltooien van de training controleren we of we de juiste resultaten behalen met behulp van de model dat we hebben gedefinieerd. We controleren het dus op een onbekende x_data waarde, in dit geval 4.0.


new_var = Variabele (toorts.Tensor ([[[ 4.0 ] ]))

pred_y = our_model ( new_var)

print ( "voorspellen ( na training) " , 4 , our_model ( new_var) .data [ 0 ] [ 0 ])

Als je alle stappen correct hebt gevolgd, zul je zien dat je voor invoer 4.0 een waarde zeer dicht bij 8,0, zoals hieronder weergegeven. Ons model leert dus in wezen de relatie tussen invoer en uitvoer zonder expliciete programmering.

predict (na training) 4 7.966438293457031

Ter referentie vindt u alle code voor dit artikel hieronder:


import torch

van torch.autograd importeren Variabele

x_data = Variabele (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 __ ( zelf ):

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

zelf . linear = torch.nn.Linear ( 1 , 1 ) # Eén invoer en één uitvoer


def forward ( zelf , x):

y_pred = zelf . lineair (x)

return y_pred


# ons model

our_model = LinearRegressionModel ()

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

optimizer = toorts.optim. SGD (our_model.parameters (), lr = 0,01 )


voor tijdperk in bereik ( 500 ):

# Forward pass: bereken voorspelde y door passeren

# —Ö om te modelleren

pred_y = our_model (x_data)


# Bereken en verlies print

loss = criterium (pred_y, y_data)


# Geen hellingen, terugpas,

# en werk het gewicht bij.

optimizer.zero_grad ()

loss.backward ()

optimizer.step ()

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


new_var = Variabele (toorts.Tensor ([[ 4.0 ]]))

pred_y = our_model (new_var)

print ( "predict (na training)" , 4 , our_model (new_var) .data [ 0 ] [ 0 ])

Links