PyTorTutorial ch

O que é PiTorhã?

PyTorch é um open-source TorBiblioteca de aprendizado de máquina baseada em ch para processamento de linguagem natural usando PythonÉ semelhante ao NumPy, mas com poderoso suporte a GPUs. Oferece grafos computacionais dinâmicos que você pode modificar em tempo real com a ajuda do autograd.py.TorO ch também é mais rápido do que algumas outras estruturas. Ele foi desenvolvido pelo Grupo de Pesquisa em IA do Facebook em 2016.

Saber o que PyTorO texto apresenta uma análise equilibrada de seus pontos fortes e fracos.

PyTorVantagens e desvantagens

A seguir, são apresentadas as vantagens e desvantagens do Py.Torch:

Vantagens do PyTorch

1. Biblioteca Simples
   PyTorO código ch é simples. É fácil de entender e você pode usar a biblioteca instantaneamente. Por exemplo, veja o trecho de código abaixo:

class Net(torch.nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

Conforme mencionado acima, você pode definir o modelo de rede facilmente e entender o código rapidamente, sem muito treinamento.

2. Gráfico Computacional Dinâmico

Fonte da imagem: Explorando o aprendizado profundo com PyTorch

PyTorO ch oferece um Grafo Computacional Dinâmico (DAG). Grafos computacionais são uma forma de expressar expressões matemáticas em modelos ou teorias de grafos, como nós e arestas. O nó realiza a operação matemática e a aresta é um tensor que é inserido nos nós e carrega a saída do nó em forma de tensor.

DAG é um gráfico que possui formato arbitrário e é capaz de realizar operações entre diferentes gráficos de entrada. A cada iteração, um novo gráfico é criado. Assim, é possível ter a mesma estrutura de gráfico ou criar um novo gráfico com uma operação diferente, ou podemos chamá-lo de gráfico dinâmico.

3. Melhor Performance

Comunidades e pesquisadores avaliam e comparam estruturas para ver qual delas é mais rápida. Um repositório GitHub Referência em estruturas de aprendizado profundo e GPUs relatou que PyTorO ch é mais rápido que o outro framework em termos de imagens processadas por segundo.

Como você pode ver abaixo, os gráficos de comparação com vgg16 e resnet152

4. Nativo Python

PyTorO ch é mais baseado em Python. Por exemplo, se você quiser treinar um modelo, pode usar o fluxo de controle nativo, como o loo.ping e recursões sem a necessidade de adicionar variáveis ​​ou sessões especiais para executá-las. Isso é muito útil para o processo de treinamento.

PyTorO ch também implementa Programação Imperativa e é definitivamente mais flexível. Portanto, é possível imprimir o valor do tensor no meio de um processo de computação.

Desvantagem do PyTorch

PyTorO ch requer aplicativos de terceiros para visualização. Também precisa de um servidor de API para produção.

A seguir neste PyTorNeste tutorial, aprenderemos sobre a diferença entre PyTorch e TensorFlow.

PyTorch vs. TensorFlow

Com a comparação em mente, o próximo passo é obter o Py.Torch executado localmente ou na nuvem.

Instalando o PyTorch

Linux

É simples instalá-lo no Linux. Você pode optar por usar um ambiente virtual ou instalá-lo diretamente com acesso root. Digite este comando no terminal

pip3 install --upgrade torch torchvision

AWS SageMaker

Sagemaker é uma das plataformas em Amazon Serviço de internet que oferece um poderoso mecanismo de aprendizado de máquina com configurações de aprendizado profundo pré-instaladas para cientistas de dados ou desenvolvedores criarem, treinarem e implantarem modelos em qualquer escala.

Primeiro abra o Amazon Sábio console e clique em Criar instância de notebook e preencha todos os detalhes do seu notebook.

Próxima etapa, clique em Abrir para iniciar sua instância de notebook.

Finalmente, em JupyterClique em Novo e escolha conda_pytorch_p36. Agora você está pronto para usar sua instância de notebook com o PyTorch.Torch instalado.

A seguir neste PyTorNeste tutorial, aprenderemos sobre Python.TorNoções básicas da estrutura CH.

Com a instalação concluída, o próximo passo é a própria API.

PyTorNoções básicas do Framework

Vamos aprender os conceitos básicos de Python.TorAntes de nos aprofundarmos, vamos analisar o capítulo seguinte. PyTorO ch utiliza Tensor para cada variável, similar ao ndarray do NumPy, mas com suporte a computação em GPU. Aqui, explicaremos o modelo de rede, a função de perda, a retropropagação e o otimizador.

Modelo de rede

A rede pode ser construída subclassificando torch.nn. Existem 2 partes principais,

1. A primeira parte é definir os parâmetros e camadas que você utilizará
2. A segunda parte é a tarefa principal chamada processo forward que receberá uma entrada e preverá a saída.

Import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
 def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 20, 5)
        self.conv2 = nn.Conv2d(20, 40, 5)
self.fc1 = nn.Linear(320, 10)

def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = x.view(-1, 320)
       x = F.relu(self.fc1(x))
       return F.log_softmax(x)

net = Model()

Como você pode ver acima, você cria uma classe de nn.Module chamada Model. Ele contém 2 camadas Conv2d e uma camada Linear. A primeira camada conv2d recebe uma entrada de 3 e o formato de saída de 20. A segunda camada receberá uma entrada de 20 e produzirá um formato de saída de 40. A última camada é uma camada totalmente conectada no formato de 320 e produzirá uma saída de 10.

O processo de encaminhamento pegará uma entrada de X e a alimentará na camada conv1 e executará a função ReLU,

Da mesma forma, também alimentará a camada conv2. Depois disso, o x será remodelado em (-1, 320) e alimentado na camada FC final. Antes de enviar a saída, você usará a função de ativação softmax.

O processo de retrocesso é definido automaticamente pelo autograd, portanto, você só precisa definir o processo de encaminhamento.

Função de perda

A função de perda é usada para medir o quão bem o modelo de previsão consegue prever os resultados esperados. PyTorO módulo torch.nn já possui diversas funções de perda padrão. Por exemplo, você pode usar a função de perda de entropia cruzada para resolver um problema de otimização multiclasse em Python.Torproblema de classificação ch. É fácil definir a função de perda e calcular as perdas:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

É fácil usar seu próprio cálculo de função de perda com Py.Torcap.

Apoio traseiro

Para realizar a retropropagação, basta chamar los.backward(). O erro será calculado, mas lembre-se de limpar o gradiente existente com zero_grad()

net.zero_grad() # to clear the existing gradient
loss.backward() # to perform backpropragation

Optimizer

O torch.optim fornece algoritmos de otimização comuns. Você pode definir um otimizador com uma etapa simples:

optimizer = torch.optim.SGD(net.parameters(), lr = 0.01, momentum=0.9)

Você precisa passar os parâmetros do modelo de rede e a taxa de aprendizado para que a cada iteração os parâmetros sejam atualizados após o processo backprop.

A maneira mais simples de aprender a API é por meio de um pequeno exemplo completo, do início ao fim.

Regressão simples com PyTorch

Vamos aprender regressão simples com Python.TorExemplos de ch:

Etapa 1) Criando nosso modelo de rede

Nosso modelo de rede é uma camada linear simples com formato de entrada e saída 1.

from __future__ import print_function

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

net = Net()
print(net)

E a saída da rede deveria ser assim

Net(
  (hidden): Linear(in_features=1, out_features=1, bias=True)
)

Etapa 2) Dados de teste

Antes de iniciar o processo de treinamento, você precisa conhecer nossos dados. Você cria uma função aleatória para testar nosso modelo. Y = x³ sen(x)+ 3x+0.8 rands(100)

# Visualize our data
import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.sin(x) * np.power(x,3) + 3*x + np.random.rand(100)*0.8

plt.scatter(x, y)
plt.show()

Aqui está o gráfico de dispersão da nossa função:

Antes de iniciar o processo de treinamento, você precisa converter o array numpy em variáveis ​​compatíveis com Torch e autograd, conforme mostrado no Py abaixo.TorExemplo de regressão ch.

# convert numpy array to tensor in shape of input size
x = torch.from_numpy(x.reshape(-1,1)).float()
y = torch.from_numpy(y.reshape(-1,1)).float()
print(x, y)

Etapa 3) Otimizador e Perda

A seguir, você deve definir o Otimizador e a Função de Perda para nosso processo de treinamento.

# Define Optimizer and Loss Function
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()

Etapa 4) Treinamento

Agora vamos iniciar nosso processo de treinamento. Com uma época de 250, você irá iterar nossos dados para encontrar o melhor valor para nossos hiperparâmetros.

inputs = Variable(x)
outputs = Variable(y)
for i in range(250):
   prediction = net(inputs)
   loss = loss_func(prediction, outputs) 
   optimizer.zero_grad()
   loss.backward()        
   optimizer.step()       

   if i % 10 == 0:
       # plot and show learning process
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color':  'red'})
       plt.pause(0.1)

plt.show()

Etapa 5) Resultado

Como você pode ver abaixo, você executou o Py com sucesso.Torregressão com uma rede neural. Na verdade, a cada iteração, a linha vermelha no gráfico será atualizada e mudará de posição para se ajustar aos dados. Mas nesta imagem, ela mostra apenas o resultado final, como mostrado no código Python abaixo.TorExemplo de ch:

A regressão é um aquecimento; a classificação de imagens exercita os músculos de aprendizado profundo do Py.Torcap.

Exemplo de classificação de imagens com PyTorch

Um dos métodos populares para aprender o básico de deep learning está com o conjunto de dados MNIST. É o “Hello World” no aprendizado profundo. O conjunto de dados contém números manuscritos de 0 a 9 com o total de 60,000 amostras de treinamento e 10,000 amostras de teste já rotuladas com o tamanho de 28×28 pixels.

Etapa 1) Pré-processar os dados

Na primeira etapa deste PyTorPara realizar um exemplo de classificação, você carregará o conjunto de dados usando o módulo torchvision.

Antes de iniciar o processo de treinamento, você precisa entender os dados. TorO chvision carregará o conjunto de dados e transformará as imagens de acordo com os requisitos apropriados para a rede, como forma e normalização das imagens.

import torch
import torchvision
import numpy as np
from torchvision import datasets, models, transforms

# This is used to transform the images to Tensor and normalize it
transform = transforms.Compose(
   [transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

training = torchvision.datasets.MNIST(root='./data', train=True,
                                       download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(training, batch_size=4,
                                         shuffle=True, num_workers=2)

testing = torchvision.datasets.MNIST(root='./data', train=False,
                                      download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(testing, batch_size=4,
                                        shuffle=False, num_workers=2)

classes = ('0', '1', '2', '3',
          '4', '5', '6', '7', '8', '9')
         
import matplotlib.pyplot as plt
import numpy as np

#create an iterator for train_loader
# get random training images
data_iterator = iter(train_loader)
images, labels = data_iterator.next()

#plot 4 images to visualize the data
rows = 2
columns = 2
fig=plt.figure()
for i in range(4):
   fig.add_subplot(rows, columns, i+1)
   plt.title(classes[labels[i]])
   img = images[i] / 2 + 0.5     # this is for unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

A função transform converte as imagens em tensor e normaliza o valor. A função torchvision.transforms.MNIST, irá baixar o conjunto de dados (se não estiver disponível) no diretório, definir o conjunto de dados para treinamento se necessário e fazer o processo de transformação.

Para visualizar o conjunto de dados, você usa o data_iterator para obter o próximo lote de imagens e rótulos. Você usa matplot para plotar essas imagens e seus rótulos apropriados. Como você pode ver abaixo nossas imagens e seus rótulos.

Etapa 2) Configuração do modelo de rede

Agora, neste PyTorPor exemplo, você criará uma rede neural simples para PyTorClassificação de imagens ch.

Aqui, apresentamos outra maneira de criar o modelo de rede em Python.TorCapítulo 1: Usaremos nn.Sequential para criar um modelo de sequência em vez de criar uma subclasse de nn.Module.

import torch.nn as nn

# flatten the tensor into 
class Flatten(nn.Module):
   def forward(self, input):
       return input.view(input.size(0), -1)

#sequential based model
seq_model = nn.Sequential(
           nn.Conv2d(1, 10, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           nn.Dropout2d(),
           nn.Conv2d(10, 20, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           Flatten(),
           nn.Linear(320, 50),
           nn.ReLU(),
           nn.Linear(50, 10),
           nn.Softmax(),
         )

net = seq_model
print(net)

Aqui está o resultado do nosso modelo de rede

Sequential(
  (0): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
  (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (2): ReLU()
  (3): Dropout2d(p=0.5)
  (4): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): ReLU()
  (7): Flatten()
  (8): Linear(in_features=320, out_features=50, bias=True)
  (9): ReLU()
  (10): Linear(in_features=50, out_features=10, bias=True)
  (11): Softmax()
)

Explicação da rede

1. A sequência é que a primeira camada é uma camada Conv2D com formato de entrada 1 e formato de saída 10 com tamanho de kernel 5
2. Em seguida, você tem uma camada MaxPool2D
3. Uma função de ativação ReLU
4. uma camada Dropout para eliminar valores de baixa probabilidade.
5. Em seguida, um segundo Conv2d com formato de entrada 10 da última camada e formato de saída 20 com tamanho de kernel 5
6. Em seguida, uma camada MaxPool2d
7. Função de ativação ReLU.
8. Depois disso, você achatará o tensor antes de alimentá-lo na camada Linear
9. A Camada Linear mapeará nossa saída na segunda camada Linear com função de ativação softmax

Etapa 3) Treine o modelo

Antes de iniciar o processo de treinamento, é necessário configurar o critério e a função do otimizador.

Para o critério de aprendizado, você usará a função de perda CrossEntropyLoss. Para o otimizador, você usará o SGD com uma taxa de aprendizado de 0.001 e um momento de 0.9, conforme mostrado no código Python abaixo.TorExemplo de ch.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

O processo de encaminhamento pegará o formato de entrada e o passará para a primeira camada conv2d. A partir daí, ele será alimentado no maxpool2d e finalmente colocado na função de ativação ReLU. O mesmo processo ocorrerá na segunda camada conv2d. Depois disso, a entrada será remodelada em (-1,320) e alimentada na camada fc para prever a saída.

Agora, você iniciará o processo de treinamento. Você irá iterar em nosso conjunto de dados 2 vezes ou com uma época de 2 e imprimir a perda atual a cada lote de 2000.

for epoch in range(2): 

#set the running loss at each epoch to zero
   running_loss = 0.0
# we will enumerate the train loader with starting index of 0
# for each iteration (i) and the data (tuple of input and labels)
   for i, data in enumerate(train_loader, 0):
       inputs, labels = data

# clear the gradient
       optimizer.zero_grad()

#feed the input and acquire the output from network
       outputs = net(inputs)

#calculating the predicted and the expected loss
       loss = criterion(outputs, labels)

#compute the gradient
       loss.backward()

#update the parameters
       optimizer.step()

       # print statistics
       running_loss += loss.item()
       if i % 1000 == 0:
           print('[%d, %5d] loss: %.3f' %
                 (epoch + 1, i + 1, running_loss / 1000))
           running_loss = 0.0

Em cada época, o enumerador obterá a próxima tupla de entrada e os rótulos correspondentes. Antes de alimentarmos nosso modelo de rede com a entrada, precisamos limpar o gradiente anterior. Isso é necessário porque após o processo reverso (processo de retropropagação), o gradiente será acumulado em vez de substituído. Em seguida, calcularemos as perdas da produção prevista a partir da produção esperada. Depois disso, faremos uma retropropagação para calcular o gradiente e, por fim, atualizaremos os parâmetros.

Aqui está o resultado do processo de treinamento

[1, 	1] loss: 0.002
[1,  1001] loss: 2.302
[1,  2001] loss: 2.295
[1,  3001] loss: 2.204
[1,  4001] loss: 1.930
[1,  5001] loss: 1.791
[1,  6001] loss: 1.756
[1,  7001] loss: 1.744
[1,  8001] loss: 1.696
[1,  9001] loss: 1.650
[1, 10001] loss: 1.640
[1, 11001] loss: 1.631
[1, 12001] loss: 1.631
[1, 13001] loss: 1.624
[1, 14001] loss: 1.616
[2, 	1] loss: 0.001
[2,  1001] loss: 1.604
[2,  2001] loss: 1.607
[2,  3001] loss: 1.602
[2,  4001] loss: 1.596
[2,  5001] loss: 1.608
[2,  6001] loss: 1.589
[2,  7001] loss: 1.610
[2,  8001] loss: 1.596
[2,  9001] loss: 1.598
[2, 10001] loss: 1.603
[2, 11001] loss: 1.596
[2, 12001] loss: 1.587
[2, 13001] loss: 1.596
[2, 14001] loss: 1.603

Etapa 4) Teste o modelo

Depois de treinar nosso modelo, você precisa testar ou avaliar outros conjuntos de imagens.

Usaremos um iterador para test_loader, e ele gerará um lote de imagens e rótulos que serão passados ​​para o modelo treinado. A saída prevista será exibida e comparada com a saída esperada.

#make an iterator from test_loader
#Get a batch of training images
test_iterator = iter(test_loader)
images, labels = test_iterator.next()

results = net(images)
_, predicted = torch.max(results, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

fig2 = plt.figure()
for i in range(4):
   fig2.add_subplot(rows, columns, i+1)
   plt.title('truth ' + classes[labels[i]] + ': predict ' + classes[predicted[i]])
   img = images[i] / 2 + 0.5     # this is to unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

Perguntas Frequentes