Förbereda data för analys

I föregående steg i den här självstudien installerade vi PyTorch på datorn. Nu ska vi använda den för att konfigurera koden med de data som vi ska använda för att skapa vår modell.

Öppna ett nytt projekt i Visual Studio.

1. Öppna Visual Studio och välj create a new project.

2. I sökfältet skriver Python och väljer du Python Application som projektmall.

3. I konfigurationsfönstret:

• Ge projektet ett namn. Här kallar vi det DataClassifier.
• Välj platsen för projektet.
• Om du använder VS2019 kontrollerar du att Create directory for solution är markerad.
• Om du använder VS2017, se till att Place solution and project in the same directory är avmarkerad.

Tryck create för att skapa projektet.

Skapa en Python-tolk

Nu måste du definiera en ny Python-tolk. Detta måste inkludera PyTorch-paketet som du nyligen har installerat.

1. Navigera till tolkalternativ och välj Add Environment:

2. I fönstret Add Environment väljer du Existing environmentoch väljer Anaconda3 (3.6, 64-bit). Detta inkluderar PyTorch-paketet.

Om du vill testa den nya Python-tolken och PyTorch-paketet anger du följande kod i DataClassifier.py filen:

from __future__ import print_function 

import torch 

x=torch.rand(2, 3) 

print(x) 

Utdata bör vara en slumpmässig 5x3 tensor som liknar nedanstående.

Anmärkning

Vill du veta mer? Besök PyTorchs officiella webbplats.

Att förstå data

Vi kommer att träna modellen på Fishers Iris-blomdatauppsättning. Denna berömda datauppsättning innehåller 50 poster för var och en av tre Iris-arter: Iris setosa, Iris virginica och Iris versicolor.

Flera versioner av datamängden har publicerats. Du hittar Iris-datauppsättningen på UCI Machine Learning-lagringsplatsen, importera datamängden direkt från Python Scikit-learn-biblioteket eller använda någon annan version som tidigare publicerats. Om du vill veta mer om Iris-blomsterdatauppsättningen kan du besöka wikipediasidan.

I den här självstudien demonstreras hur du tränar modellen med den tabulära typen av indata genom att använda Iris-datasetet, som har exporterats till en Excel-fil.

Varje rad i Excel-tabellen visar fyra funktioner i Iris: sepallängd i cm, sepalbredd i cm, kronbladslängd i cm och kronbladsbredd i cm. Dessa funktioner fungerar som dina indata. Den sista kolumnen innehåller den Iris-typ som är relaterad till dessa parametrar och representerar regressionsutdata. Totalt innehåller datamängden 150 indata av fyra funktioner, var och en av dem matchas med relevant Iris-typ.

Regressionsanalysen tittar på relationen mellan indatavariabler och resultatet. Baserat på indata lär sig modellen att förutsäga rätt typ av utdata – en av de tre Iris-typerna: Iris-setosa, Iris-versicolor, Iris-virginica.

Viktigt!

Om du bestämmer dig för att använda andra datauppsättningar för att skapa en egen modell måste du ange dina indatavariabler och utdata för modellen enligt ditt scenario.

Läs in datauppsättningen.

1. Ladda ned Iris-datauppsättningen i Excel-format. Du hittar den här.

2. DataClassifier.py I filen i mappen Solution Explorer Files lägger du till följande importinstruktion för att få åtkomst till alla paket som vi behöver.

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 

Som du ser använder du pandas-paketet (Python-dataanalys) för att läsa in och manipulera data och torch.nn-paket som innehåller moduler och utökningsbara klasser för att skapa neurala nätverk.

3. Läs in data i minnet och verifiera antalet klasser. Vi förväntar oss att se 50 objekt av varje Iris-typ. Se till att ange platsen för datauppsättningen på datorn.

Lägg till följande kod i DataClassifier.py-filen:

# 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()) 

När vi kör den här koden är de förväntade utdata följande:

För att kunna använda datamängden och träna modellen måste vi definiera indata och utdata. Indata innehåller 150 rader egenskaper och utdata är Iris-typkolumnen. Det neurala nätverk som vi ska använda kräver numeriska variabler, så du konverterar utdatavariabeln till ett numeriskt format.

4. Skapa en ny kolumn i datauppsättningen som representerar utdata i ett numeriskt format och definiera en regressionsindata och utdata.

Lägg till följande kod i DataClassifier.py-filen:

# 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()) 

När vi kör den här koden är de förväntade utdata följande:

För att träna modellen måste vi konvertera modellens indata och utdata till Tensor-formatet:

5. Konvertera till Tensor:

Lägg till följande kod i DataClassifier.py-filen:

# 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 

Om vi kör koden visar de förväntade utdataformaten indata och utdata enligt följande:

Det finns 150 indatavärden. Cirka 60% kommer att vara modellträningsdata. Du behåller 20% för validering och 30% för ett test.

I den här handledningen definieras batchstorleken för en träningsdatauppsättning som 10. Det finns 95 objekt i träningsuppsättningen, vilket innebär att det i genomsnitt finns 9 fullständiga batchar att iterera genom träningsuppsättningen en gång (en epok). Du behåller batchstorleken för validerings- och testuppsättningarna som 1.

6. Dela upp data för att träna, validera och testa uppsättningar:

Lägg till följande kod i DataClassifier.py-filen:

# 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)

Nästa steg

När data är klara är det dags att träna vår PyTorch-modell