Régression linéaire avec PyTorch

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

Tout d`abord, vous devrez installer PyTorch dans votre environnement Python. La façon la plus simple de le faire est — utilisez l`outil pip ou conda . Visitez pytorch.org et installez la version de votre interpréteur Python et gestionnaire de packages que vous souhaitez utiliser.


# Nous pouvons exécuter ce code Python sur un notebook Jupyter
# pour installer automatiquement la bonne version
# PyTorch.


# http://pytorch.org / depuis le chemin d`importation du système d`exploitation

depuis wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag

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

accélérateur = `cu80` if path.exists ( `/opt/bin/nvidia-smi` ) else `cpu`


 ! pip install - q http: / / download.pytorch.org / whl / {accélérateur} / torche - 0.3 . 0.post4 - {platform} - linux_x86_64.whl torchvision

Avec PyTorch installé, passons maintenant regardez le code.
Écrivez les deux lignes ci-dessous pour importer les fonctions et objets de bibliothèque requis.


import torche

de torch.autograd importer Variable

Nous définissons également certaines données et les attribuons aux variables x_data et y_data, comme suit :


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

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

Ici x_data & #8212 ; notre variable indépendante, et y_data — notre variable dépendante. Ce sera notre jeu de données pour le moment. Ensuite, nous devons définir notre modèle. La définition de notre modèle comporte deux étapes principales. Ce sont :

  1. Initialiser notre modèle.
  2. Déclarer une passe avant.

Nous utilisons la classe ci-dessous :

class Modèle de régression linéaire (torch.nn.Module) :


def __ init __ ( soi ) :

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

soi . linéaire = torch.nn.Linear ( 1 , 1 ) # Une entrée et une sortie


def forward ( soi , x):

y_pred = soi . linéaire (x)

return y_pred

Comme vous pouvez le voir, notre classe Model est une sous-classe de torch.nn.module. De plus, comme nous n`avons ici qu`une seule entrée et une seule sortie, nous utilisons un modèle linéaire avec une taille d`entrée et de sortie de 1.

Ensuite, nous créons un objet de ce modèle.

# notre modèle

our_model = LinearRegressionModel ()

Après cela, choisissez un optimiseur et critère de perte. Ici, nous utiliserons l`erreur quadratique moyenne (MSE) comme fonction de perte et la descente de gradient stochastique (SGD) comme optimiseur. Nous fixons également arbitrairement le taux d`apprentissage à 0,01.


critère = torch.nn.MSELoss (size_average = Faux )

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

Nous arrivons maintenant à notre phase d`apprentissage. Nous effectuons les tâches suivantes 500 fois pendant la formation :

  1. Effectuez un transfert en direct en transmettant nos données et en déterminant la valeur y prévue.
  2. Calculez la perte à l`aide de MSE.
  3. Réinitialisez tous les dégradés à 0, rétro-propagez puis mettez à jour les poids.

pour époque dans plage ( 500 ) :


# Passe avant : calcule l`y prévu en passant

#x au modèle

pred_y = our_model (x_data)


# Calculer et perdre l`impression

perte = critère (pred_y, y_data)


# Gradients nuls, retour en arrière

# et mettez à jour le poids.

optimiseur.zero_grad ()

loss.backward ()

optimiseur.step ()

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

Après avoir terminé la formation, nous vérifions si nous obtenons les bons résultats en utilisant le modèle que nous avons défini. Nous le vérifions donc pour une valeur x_data inconnue, dans ce cas 4.0.


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

pred_y = our_model ( new_var)

print ( "prédire ( après l`entraînement) " , 4 , our_model ( new_var) .data [ 0 ] [ 0 ])

Si vous avez suivi toutes les étapes correctement, vous verrez que pour l`entrée 4.0 vous obtenez un valeur très proche de 8,0, comme indiqué ci-dessous. Ainsi, notre modèle apprend essentiellement la relation entre l`entrée et la sortie sans programmation explicite.

predict (after training) 4 7.966438293457031

Pour référence, vous pouvez trouver tout le code de cet article ci-dessous :


import torch

de torch.autograd importer Variable

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

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



classe Modèle de régression linéaire (torch.nn.Module) :


def __ init __ ( soi ) :

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

self . linear = torch.nn.Linear ( 1 , 1 ) # Une entrée et une sortie


def forward ( soi , x):

y_pred = soi . linéaire (x)

return y_pred


# notre modèle

our_model = Modèle de régression linéaire ()

critère = torch.nn.MSELoss (size_average = False )

optimiseur = torche.optim. SGD (our_model.parameters (), lr = 0.01 )


pour époque dans plage ( 500 ) :

# Passe avant : calcule l`y prévu en passant

# —Ö pour modéliser

pred_y = our_model (x_data)


# Calculer et perdre print

loss = critère (pred_y, y_data)


# Dégradés zéro, passe arrière,

# et mettez à jour le poids.

optimiseur.zero_grad ()

loss.backward ()

optimiseur.step ()

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


new_var = Variable (torche.Tensor ([[ 4.0 ]]))

pred_y = our_model (new_var)

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

Liens