Tutorial PyTorch com regressão linear

PyTorch é um pacote científico baseado em Python que fornece uma substituição de NumPy ndarrays como Tensores que tira o máximo proveito das GPUs. Outro ponto positivo sobre o framework PyTorch é a velocidade e flexibilidade que ele fornece durante a computação. PyTorch é uma alternativa eficiente de trabalhar com Tensores usando Tensorflow, que estudamos anteriormente.

O PyTorch tem poucas grandes vantagens como pacote de computação, tais como:

É possível construir gráficos de computação à medida que avançamos. Isso significa que não é necessário saber com antecedência sobre os requisitos de memória do gráfico. Podemos criar livremente uma rede neural e avaliá-la durante o tempo de execução.
API fácil de Python, que é facilmente integrável
Apoiado pelo Facebook, então o apoio da comunidade é muito forte
Fornece suporte multi-GPU nativamente

PyTorch é adotado principalmente pela comunidade de ciência de dados devido à sua capacidade de definir redes neurais de forma conveniente. Vamos ver este pacote computacional em ação nesta lição.

Instalando PyTorch

Só uma observação antes de começar, você pode usar um ambiente virtual para esta lição que podemos fazer com o seguinte comando:

python -m virtualenv pytorch
fonte pytorch / bin / activate

Assim que o ambiente virtual estiver ativo, você pode instalar a biblioteca PyTorch dentro do ambiente virtual para que os exemplos que criaremos a seguir possam ser executados:

pip install pytorch

Faremos uso do Anaconda e do Jupyter nesta lição. Se você deseja instalá-lo em sua máquina, veja a lição que descreve “Como instalar o Anaconda Python no Ubuntu 18.04 LTS ”e compartilhe seu feedback se você enfrentar quaisquer problemas. Para instalar o PyTorch com Anaconda, use o seguinte comando no terminal do Anaconda:

conda install -c pytorch pytorch

Vemos algo assim quando executamos o comando acima:

Assim que todos os pacotes necessários estiverem instalados e prontos, podemos começar a usar a biblioteca PyTorch com a seguinte instrução de importação:

importar tocha

Vamos começar com exemplos básicos do PyTorch agora que temos os pacotes de pré-requisitos instalados.

Introdução ao PyTorch

Como sabemos que as redes neurais podem ser fundamentalmente estruturadas como Tensores e o PyTorch é construído em torno de tensores, tende a haver um aumento significativo no desempenho. Começaremos com o PyTorch examinando primeiro o tipo de tensores que ele fornece. Para começar, importe os pacotes necessários:

importar tocha

Em seguida, podemos definir um Tensor não inicializado com um tamanho definido:

x = tocha.vazio (4, 4)
print ("Tipo de matriz: ".formato (x.tipo)) # tipo
print ("Forma de matriz: ".formato (x.forma)) # forma
imprimir (x)

Vemos algo assim quando executamos o script acima:

Acabamos de fazer um tensor não inicializado com um tamanho definido no script acima. Para reiterar nossa lição do Tensorflow, tensores podem ser denominados como matriz n-dimensional o que nos permite representar dados em dimensões complexas.

Vamos executar outro exemplo onde inicializamos um tensor Torched com valores aleatórios:

random_tensor = tocha.rand (5, 4)
imprimir (random_tensor)

Quando executamos o código acima, veremos um objeto tensor aleatório impresso:

Observe que a saída para o Tensor aleatório acima pode ser diferente para você porque, bem, é aleatório !

Conversão entre NumPy e PyTorch

NumPy e PyTorch são completamente compatíveis um com o outro. É por isso que é fácil transformar matrizes NumPy em tensores e vice-versa. Além da facilidade que a API fornece, provavelmente é mais fácil visualizar os tensores na forma de matrizes NumPy em vez de Tensores, ou apenas chamá-lo de meu amor por NumPy!

Por exemplo, vamos importar NumPy em nosso script e definir uma matriz aleatória simples:

importar numpy como np
array = np.aleatória.rand (4, 3)
transformou_tensor = tocha.from_numpy (array)
imprimir (" \ n".formato (transformado_tensor))

Quando executarmos o código acima, veremos o objeto tensor transformado impresso:

Agora, vamos tentar converter este tensor de volta em uma matriz NumPy:

numpy_arr = transform_tensor.entorpecido ()
imprimir (" \ n".formato (tipo (numpy_arr), numpy_arr))

Quando executarmos o código acima, veremos a matriz NumPy transformada impressa:

Se olharmos de perto, até mesmo a precisão da conversão é mantida durante a conversão do array em um tensor e depois convertê-lo de volta em um array NumPy.

Operações de tensor

Antes de começar nossa discussão sobre redes neurais, devemos conhecer as operações que podem ser realizadas em Tensores durante o treinamento de redes neurais. Faremos uso extensivo do módulo NumPy também.

Cortando um Tensor

Já vimos como fazer um novo Tensor, vamos fazer um agora e fatiar isto:

vector = tocha.tensor ([1, 2, 3, 4, 5, 6])
imprimir (vetor [1: 4])

O snippet de código acima nos fornecerá a seguinte saída:

tensor ([2, 3, 4])

Podemos ignorar o último índice:

imprimir (vetor [1:])

E também receberemos de volta o que é esperado com uma lista Python:

tensor ([2, 3, 4, 5, 6])

Fazendo um Tensor Flutuante

Vamos agora fazer um Tensor flutuante:

float_vector = torch.FloatTensor ([1, 2, 3, 4, 5, 6])
imprimir (float_vector)

O snippet de código acima nos fornecerá a seguinte saída:

tensor ([1., 2., 3., 4., 5., 6.])

O tipo deste tensor será:

imprimir (float_vector.dtype)

Retribui:

tocha.float32

Operações aritméticas em tensores

Podemos adicionar dois tensores como quaisquer elementos matemáticos, como:

tensor_1 = tocha.tensor ([2, 3, 4])
tensor_2 = tocha.tensor ([3, 4, 5])
tensor_1 + tensor_2

O snippet de código acima nos dará:

Podemos multiplicar um tensor com um escalar:

tensor_1 * 5

Isso nos dará:

Podemos realizar um produto escalar entre dois tensores também:

d_product = tocha.ponto (tensor_1, tensor_2)
d_product

O snippet de código acima nos fornecerá a seguinte saída:

Na próxima seção, veremos dimensões superiores de tensores e matrizes.

Multiplicação da matriz

Nesta seção, veremos como podemos definir métricas como tensores e multiplicá-los, assim como costumávamos fazer na matemática do ensino médio.

Vamos definir uma matriz para começar com:

matriz = tocha.tensor ([1, 3, 5, 6, 8, 0]).ver (2, 3)

No trecho de código acima, definimos uma matriz com a função tensor e, em seguida, especificamos com função de visualização que deve ser feito como um tensor bidimensional com 2 linhas e 3 colunas. Podemos fornecer mais argumentos para o visualizar função para especificar mais dimensões. Observe que:

contagem de linhas multiplicada pela contagem de colunas = contagem de itens

Quando visualizamos o tensor bidimensional acima, veremos a seguinte matriz:

Vamos definir outra matriz idêntica com uma forma diferente:

matrix_b = tocha.tensor ([1, 3, 5, 6, 8, 0]).ver (3, 2)

Podemos finalmente realizar a multiplicação agora:

tocha.matmul (matriz, matriz_b)

O snippet de código acima nos fornecerá a seguinte saída:

Regressão Linear com PyTorch

A regressão linear é um algoritmo de aprendizado de máquina baseado em técnicas de aprendizado supervisionado para realizar análises de regressão em uma variável independente e dependente. Já confuso? Vamos definir a regressão linear em palavras simples.

A regressão linear é uma técnica para descobrir a relação entre duas variáveis e prever quanta mudança na variável independente causa quanta mudança na variável dependente. Por exemplo, o algoritmo de regressão linear pode ser aplicado para descobrir quanto aumenta o preço de uma casa quando sua área é aumentada em um certo valor. Ou quanta potência há em um carro com base no peso do motor. O 2º exemplo pode parecer estranho, mas você sempre pode tentar coisas estranhas e quem sabe se você consegue estabelecer uma relação entre esses parâmetros com Regressão Linear!

A técnica de regressão linear geralmente usa a equação de uma linha para representar a relação entre a variável dependente (y) e a variável independente (x):

y = m * x + c

Na equação acima:

m = inclinação da curva
c = polarização (ponto que intercepta o eixo y)

Agora que temos uma equação que representa o relacionamento de nosso caso de uso, tentaremos configurar alguns dados de amostra junto com uma visualização de gráfico. Aqui estão os dados de amostra para preços de casas e seus tamanhos:

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.array (house_prices_array, dtype = np.float32)
house_price_np = house_price_np.remodelar (-1,1)
house_price_tensor = Variável (tocha.from_numpy (house_price_np))
tamanho_ casa = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.matriz (tamanho_casa, tipo_d = np.float32)
house_size_np = house_size_np.remodelar (-1, 1)
house_size_tensor = Variável (tocha.from_numpy (house_size_np))
# permite visualizar nossos dados
importar matplotlib.pyplot como plt
plt.dispersão (house_prices_array, house_size_np)
plt.xlabel ("Preço interno $")
plt.ylabel ("tamanhos internos")
plt.título ("Preço da casa $ VS tamanho da casa")
plt

Observe que usamos Matplotlib, que é uma excelente biblioteca de visualização. Leia mais sobre isso no Tutorial Matplotlib. Veremos o seguinte gráfico depois de executar o snippet de código acima:

Quando fazemos uma linha através dos pontos, pode não ser perfeita, mas ainda é o suficiente para o tipo de relação que as variáveis têm. Agora que coletamos e visualizamos nossos dados, queremos fazer uma previsão de qual será o tamanho da casa se ela for vendida por $ 650.000.

O objetivo da aplicação de regressão linear é encontrar uma linha que se ajuste aos nossos dados com erro mínimo. Aqui estão as etapas que iremos realizar para aplicar o algoritmo de regressão linear aos nossos dados:

Construir uma classe para regressão linear
Defina o modelo desta classe de regressão linear
Calcule o MSE (erro quadrático médio)
Realize a otimização para reduzir o erro (SGD i.e. descida gradiente estocástico)
Executar retropropagação
Finalmente, faça a previsão

Vamos começar a aplicar as etapas acima com as importações corretas:

importar tocha
da tocha.Variável de importação de autograd
importar tocha.nn como nn

A seguir, podemos definir nossa classe de regressão linear que herda do módulo de rede neural PyTorch:

classe LinearRegression (nn.Módulo):
def __init __ (self, input_size, output_size):
# superfunção herda de nn.Módulo para que possamos acessar tudo de nn.Módulo
super (LinearRegression, self).__iniciar__()
# Função linear
auto.linear = nn.Linear (input_dim, output_dim)
def forward (self, x):
retornar a si mesmo.linear (x)

Agora que estamos prontos com a classe, vamos definir nosso modelo com tamanho de entrada e saída de 1:

input_dim = 1
output_dim = 1
model = LinearRegression (input_dim, output_dim)

Podemos definir o MSE como:

mse = nn.MSELoss ()

Estamos prontos para definir a otimização que pode ser realizada na previsão do modelo para melhor desempenho:

# Otimização (encontre parâmetros que minimizem o erro)
learning_rate = 0.02
otimizador = tocha.otim.SGD (modelo.parâmetros (), lr = learning_rate)

Podemos finalmente fazer um gráfico para a função de perda em nosso modelo:

loss_list = []
iteration_number = 1001
para iteração no intervalo (iteration_number):
# realizar otimização com gradiente zero
otimizador.zero_grad ()
resultados = modelo (house_price_tensor)
perda = mse (resultados, house_size_tensor)
# calcule a derivada retrocedendo
perda.para trás()
# Atualizando parâmetros
otimizador.Passo()
# perda de loja
loss_list.anexar (perda.dados)
# perda de impressão
if (iteração% 50 == 0):
imprimir ('época , perda '.formato (iteração, perda.dados))
plt.plot (intervalo (iteration_number), loss_list)
plt.xlabel ("Número de Iterações")
plt.ylabel ("Perda")
plt

Realizamos otimizações várias vezes na função de perda e tentamos visualizar o quanto a perda aumentou ou diminuiu. Aqui está o gráfico que é o resultado:

Vemos que à medida que o número de iterações é maior, a perda tende a zero. Isso significa que estamos prontos para fazer nossa previsão e traçá-la:

# prever o preço do nosso carro
predicted = model (house_price_tensor).dados.entorpecido ()
plt.dispersão (house_prices_array, house_size, label = "dados originais", color = "red")
plt.dispersão (house_prices_array, predicted, label = "predicted data", color = "blue")
plt.lenda()
plt.xlabel ("Preço interno $")
plt.ylabel ("tamanho da casa")
plt.título ("Valores originais vs valores previstos")
plt.mostrar()

Aqui está o enredo que nos ajudará a fazer a previsão:

Conclusão

Nesta lição, vimos um excelente pacote de computação que nos permite fazer previsões mais rápidas e eficientes e muito mais. PyTorch é popular devido à maneira como nos permite gerenciar redes neurais de uma forma fundamental com tensores.