Regressão linear usando PyTorch

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

Primeiro, você precisará instalar o PyTorch em seu ambiente Python. A maneira mais fácil de fazer isso é — use a ferramenta pip ou conda . Visite pytorch.org e instale a versão do seu interpretador Python e gerenciador de pacotes que você gostaria de usar.


# Podemos executar este código Python em um notebook Jupyter
# para instalar automaticamente a versão correta
# PyTorch.


# http://pytorch.org / from OS import path

from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag

plataforma = `{} {} - {}` . formato (get_abbr_impl (), get_impl_ver (), get_abi_tag ())

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


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

Com o PyTorch instalado, vamos agora veja o código.
Escreva as duas linhas abaixo para importar as funções e objetos de biblioteca necessários.


importar tocha

from torch.autograd import Variável

Também definimos alguns dados e os atribuímos às variáveis x_data e y_data, da seguinte forma:


x_data = Variável (torch.Tensor ([[ 1.0 ], [ 2.0 ], [ 3.0 ]]))

y_data = Variável (torch.Tensor ([[ 2.0 ], [ 4.0 ], [ 6.0 ]]))

Aqui x_data & #8212; nossa variável independente e y_data — nossa variável dependente. Este será nosso conjunto de dados por enquanto. Em seguida, precisamos definir nosso modelo. Existem duas etapas principais envolvidas na definição do nosso modelo. São eles:

  1. Inicializando nosso modelo.
  2. Declarando um passe para frente.

Usamos a classe abaixo:

class LinearRegressionModel (torch.nn.Module):


def __ init __ ( self ):

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

self . linear = torch.nn.Linear ( 1 , 1 ) # Uma entrada e uma saída


def forward ( self , x):

y_pred = self . linear (x)

return y_pred

Como você pode ver, nossa classe Model é uma subclasse de torch.nn.module. Além disso, como temos apenas uma entrada e uma saída aqui, usamos um modelo linear com tamanho de entrada e saída de 1.

Em seguida, criamos um objeto desse modelo.

# nosso modelo

our_model = LinearRegressionModel ()

Depois disso, escolha um otimizador e critérios de perda. Aqui usaremos o erro quadrático médio (MSE) como nossa função de perda e a Descida do Gradiente Estocástico (SGD) como nosso otimizador. Também fixamos arbitrariamente a taxa de aprendizado em 0,01.


critério = torch.nn.MSELoss (size_average = False )

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

Agora chegamos ao nosso estágio de aprendizado. Realizamos as seguintes tarefas 500 vezes durante o treinamento:

  1. Realize uma transferência ao vivo passando nossos dados e descobrindo o valor de y previsto.
  2. Calcule a perda usando o MSE.
  3. Redefinir todos os gradientes para 0, propagar de volta e atualizar os pesos.

para época em intervalo ( 500 ):


# Forward pass: calcula y previsto passando

#x para o modelo

pred_y = our_model (x_data)


# Calcula e perde a impressão

perda = critério (pred_y, y_data)


# Zero gradientes, backtrack

# e atualize o peso.

optimizer.zero_grad ()

loss.backward ()

optimizer.step ()

print ( ` época {}, perda {} ` . formato (epoch, loss.data [ 0 ]))

Após concluir o treinamento, verificamos se estamos obtendo os resultados corretos usando o modelo que definimos. Portanto, verificamos se há um valor x_data desconhecido, neste caso 4.0.


new_var = Variável (torch.Tensor ([[[ 4.0 ] ]))

pred_y = our_model ( new_var)

print ( "prever (após o treinamento)" , 4 , our_model ( new_var) .data [ 0 ] [ 0 ])

Se você seguiu todas as etapas corretamente, você verá que para a entrada 4.0 você obtém uma valor muito próximo de 8,0, conforme mostrado abaixo. Assim, nosso modelo essencialmente aprende a relação entre entrada e saída sem programação explícita.

prever (após o treinamento) 4 7.966438293457031

Para referência, você pode encontrar todo o código para este artigo abaixo:


import tocha

from torch.autograd importar Variável

x_data = Variável (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 ) # Uma entrada e uma saída


def forward ( self , x):

y_pred = self . linear (x)

return y_pred


# nosso modelo

our_model = LinearRegressionModel ()

critério = torch.nn.MSELoss (size_average = False )

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


para época em intervalo ( 500 ):

# Forward pass: calcula y previsto passando

# —Ö para modelar

pred_y = our_model (x_data)


# Calcula e perde impressão

perda = critério (pred_y, y_data)


# Zero gradientes, retrocesso,

# e atualização do peso.

optimizer.zero_grad ()

loss.backward ()

optimizer.step ()

print ( `época {}, perda {}` . formato (epoch, loss.data [ 0 ]))


new_var = Variável (torch.Tensor ([[ 4.0 ]]))

pred_y = our_model (new_var)

print ( "prever (após o treinamento)" , 4 , our_model (new_var) .data [ 0 ] [ 0 ])

Links