Preparar dados para análise

Na etapa anterior deste tutorial, instalamos o PyTorch no seu computador. Agora, vamos usá-lo para configurar o código com os dados que vamos usar para criar o modelo.

Abrir um novo projeto no Visual Studio.

1. Abra o Visual Studio e escolha create a new project.

2. Na barra de pesquisa, digite Python e selecione Python Application como o modelo de projeto.

3. Na janela de configuração:

• Nomeie o projeto. Aqui, o nome será DataClassifier.
• Escolha o local do projeto.
• Se você está usando o VS2019, verifique se Create directory for solution está marcado.
• Se estiver usando o VS2017, verifique se a opção Place solution and project in the same directory está desmarcada.

Pressione create para criar o projeto.

Criar um interpretador do Python

Você precisa definir um novo interpretador do Python. Isso deve incluir o pacote PyTorch instalado recentemente.

1. Navegue até a seleção do interpretador e selecione Add Environment:

2. Na janela Add Environment, selecione Existing environment e escolha Anaconda3 (3.6, 64-bit). Isso inclui o pacote PyTorch.

Para testar o novo interpretador do Python e o pacote PyTorch, insira o seguinte código no arquivo DataClassifier.py:

from __future__ import print_function 

import torch 

x=torch.rand(2, 3) 

print(x) 

A saída deve ser um tensor 5x3 aleatório semelhante ao apresentado abaixo.

Observação

Quer aprender mais? Visite o site oficial do PyTorch.

Compreendendo os dados

O modelo será treinado no conjunto de dados de flor de íris de Fisher. Esse conhecido conjunto de dados inclui 50 registros de cada uma das três espécies de íris: {i>Iris setosaIris virginicaIris versicolor

Várias versões do conjunto de dados já foram publicadas. O conjunto de dados Íris pode ser encontrado no Repositório de Machine Learning da UCI, importado diretamente da biblioteca Python Scikit-learn ou você pode usar qualquer outra versão já publicada. Para saber mais sobre o conjunto de dados Íris, visite a página dele na Wikipédia.

Neste tutorial, para demonstrar como treinar o modelo com o tipo de entrada tabular, você usará o conjunto de dados Íris exportado para o arquivo Excel.

Cada linha de tabela do Excel mostrará quatro recursos da íris: comprimento da sépala em centímetros, largura da sépala em centímetros, comprimento da pétala em centímetros e largura da pétala em centímetros. Esses recursos serão a entrada. A última coluna é a espécie de íris relacionada a esses parâmetros e representará a saída de regressão. No total, o conjunto de dados tem 150 entradas de quatro recursos, cada uma delas correspondente à espécie de íris relevante.

A análise de regressão examina a relação entre as variáveis de entrada e o resultado. Com base na entrada, o modelo aprenderá a prever o tipo correto de saída – uma das três espécies de íris: {i>Iris setosaIris versicolorIris virginica

Importante

Se você decidir usar qualquer outro conjunto de dados para criar um modelo, será necessário especificar as variáveis de entrada do modelo e a saída de acordo com seu cenário.

Carregue o conjunto de dados.

1. Baixe o conjunto de dados Íris no formato Excel. Você pode encontrá-lo aqui.

2. No arquivo DataClassifier.py na pasta Arquivos do Gerenciador de Soluções, adicione a seguinte instrução de importação para ter acesso a todos os pacotes de que precisaremos.

import torch 
import pandas as pd 
import torch.nn as nn 
from torch.utils.data import random_split, DataLoader, TensorDataset 
import torch.nn.functional as F 
import numpy as np 
import torch.optim as optim 
from torch.optim import Adam 

Como você pode ver, você usará o pacote pandas (análise de dados do Python) para carregar e manipular dados e o pacote torch.nn que contém módulos e classes extensíveis para a criação de redes neurais.

3. Carregue os dados na memória e verifique o número de classes. Esperamos ver 50 itens de cada espécie de íris. Não se esqueça de especificar o local do conjunto de dados em seu computador.

Adicione o seguinte código ao arquivo DataClassifier.py.

# Loading the Data
df = pd.read_excel(r'C:…\Iris_dataset.xlsx') 
print('Take a look at sample from the dataset:') 
print(df.head()) 

# Let's verify if our data is balanced and what types of species we have  
print('\nOur dataset is balanced and has the following values to predict:') 
print(df['Iris_Type'].value_counts()) 

Quando executamos esse código, a saída esperada é a seguinte:

Para usar o conjunto de dados e treinar o modelo, é necessário definir a entrada e a saída. A entrada é de 150 linhas de recursos; a saída é a coluna "Espécie de íris". A rede neural a ser usada requer variáveis numéricas, portanto, você converterá a variável de saída em um formato numérico.

4. Crie uma coluna no conjunto de dados que representará a saída em um formato numérico e defina uma entrada e uma saída de regressão.

Adicione o seguinte código ao arquivo DataClassifier.py.

# Convert Iris species into numeric types: Iris-setosa=0, Iris-versicolor=1, Iris-virginica=2.  
labels = {'Iris-setosa':0, 'Iris-versicolor':1, 'Iris-virginica':2} 
df['IrisType_num'] = df['Iris_Type']   # Create a new column "IrisType_num" 
df.IrisType_num = [labels[item] for item in df.IrisType_num]  # Convert the values to numeric ones 

# Define input and output datasets 
input = df.iloc[:, 1:-2]            # We drop the first column and the two last ones. 
print('\nInput values are:') 
print(input.head())   
output = df.loc[:, 'IrisType_num']   # Output Y is the last column  
print('\nThe output value is:') 
print(output.head()) 

Quando executamos esse código, a saída esperada é a seguinte:

Para treinar o modelo, é preciso converter a entrada e a saída do modelo no formato tensor:

5. Converter em tensor:

Adicione o seguinte código ao arquivo DataClassifier.py.

# Convert Input and Output data to Tensors and create a TensorDataset 
input = torch.Tensor(input.to_numpy())      # Create tensor of type torch.float32 
print('\nInput format: ', input.shape, input.dtype)     # Input format: torch.Size([150, 4]) torch.float32 
output = torch.tensor(output.to_numpy())        # Create tensor type torch.int64  
print('Output format: ', output.shape, output.dtype)  # Output format: torch.Size([150]) torch.int64 
data = TensorDataset(input, output)    # Create a torch.utils.data.TensorDataset object for further data manipulation 

Se você executar o código, a saída esperada mostrará o formato de entrada e saída, desta maneira:

Há 150 valores de entrada. Cerca de 60% serão os dados de treinamento do modelo. Você continuará com 20% para validação e 30% para teste.

Neste tutorial, o tamanho do lote de um conjunto de dados de treinamento é de dez. Há 95 itens no conjunto de treinamento, o que significa que, em média, há nove lotes completos para iterar por meio do conjunto de treinamento uma vez (uma época). Você manterá o tamanho do lote dos conjuntos de validação e de teste como 1.

6. Divida os dados em conjuntos de treinamento, validação e teste:

Adicione o seguinte código ao arquivo DataClassifier.py.

# Split to Train, Validate and Test sets using random_split 
train_batch_size = 10        
number_rows = len(input)    # The size of our dataset or the number of rows in excel table.  
test_split = int(number_rows*0.3)  
validate_split = int(number_rows*0.2) 
train_split = number_rows - test_split - validate_split     
train_set, validate_set, test_set = random_split( 
    data, [train_split, validate_split, test_split])    
 
# Create Dataloader to read the data within batch sizes and put into memory. 
train_loader = DataLoader(train_set, batch_size = train_batch_size, shuffle = True) 
validate_loader = DataLoader(validate_set, batch_size = 1) 
test_loader = DataLoader(test_set, batch_size = 1)

Próximas etapas

Com os dados prontos para uso, é hora de treinar o modelo PyTorch