Preparación de los datos para análisis

En la fase anterior de este tutorial, instalamos PyTorch en la máquina. Ahora lo usaremos para configurar el código con los datos que utilizaremos para crear el modelo.

Abra un nuevo proyecto en Visual Studio.

1. Abra Visual Studio y elija create a new project.

2. En la barra de búsqueda, escriba Python y seleccione Python Application como plantilla de proyecto.

3. En la ventana de configuración:

• Dé un nombre al proyecto. Aquí, lo llamamos DataClassifier.
• Elija la ubicación del proyecto.
• Si usa VS2019, asegúrese de que la opción Create directory for solution esté activada.
• Si usa VS2017, asegúrese de que la opción Place solution and project in the same directory esté desactivada.

Presione create para crear el proyecto.

Creación de un intérprete de Python

En esta sección debe definir un nuevo intérprete de Python. Recuerde que debe incluir el paquete de PyTorch que instaló recientemente.

1. Vaya a la selección del intérprete y seleccione Add Environment:

2. En la ventana Add Environment, seleccione Existing environment y elija Anaconda3 (3.6, 64-bit). Esta opción incluye el paquete de PyTorch.

Para probar el nuevo intérprete de Python y el paquete de PyTorch, escriba el código siguiente en el archivo DataClassifier.py:

from __future__ import print_function 

import torch 

x=torch.rand(2, 3) 

print(x) 

El resultado debe ser un tensor aleatorio de 5 x 3 similar al siguiente.

Nota:

¿Quiere saber más sobre el tema? Visite el sitio web oficial de PyTorch.

Descripción de los datos

Entrenaremos el modelo con el conjunto de datos de flores Iris de Fisher. Este famoso conjunto de datos incluye 50 registros para cada una de las tres especie de Iris: Iris setosa, Iris virginica e Iris versicolor.

Se han publicado varias versiones del conjunto de datos. Puede encontrar el conjunto de datos Iris en el repositorio de aprendizaje automático de UCI. Impórtelo directamente desde la biblioteca Scikit-learn de Python o use cualquier otra versión publicada anteriormente. Para obtener información sobre el conjunto de datos de flores Iris, visite la página de Wikipedia correspondiente.

En este tutorial, para mostrar cómo entrenar el modelo con las entradas de tipo tabular, usará el conjunto de datos Iris exportado al archivo de Excel.

Cada línea de la tabla de Excel mostrará cuatro características de Iris: longitud del sépalo en cm, ancho del sépalo en cm, longitud del pétalo en cm y ancho del pétalo en cm. Estas características servirán como entrada. La última columna incluye el tipo de Iris relacionado con estos parámetros y representará la salida de regresión. En total, el conjunto de datos incluye 150 entradas de cuatro características, cada una de ellas coincidente con el tipo de Iris correspondiente.

El análisis de regresión examina la relación entre las variables de entrada y el resultado. En función de la entrada, el modelo aprenderá a predecir el tipo correcto de salida: uno de los tres tipos de Iris: Iris setosa, Iris versicolor, Iris virginica.

Importante

Si decide usar cualquier otro conjunto de datos para crear su propio modelo, deberá especificar las variables de entrada y salida del modelo según su escenario.

Cargue el conjunto de datos.

1. Descargue el conjunto de datos de Iris en formato Excel. Puede encontrarlo aquí.

2. En el archivo DataClassifier.py de la carpeta Solution Explorer Files, agregue la siguiente instrucción de importación para obtener acceso a todos los paquetes que se necesitarán.

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 puede ver, va a usar el paquete pandas (análisis de datos de Python) para cargar y manipular datos, así como el paquete de torch.nn que contiene módulos y clases extensibles para crear redes neuronales.

3. Cargue los datos en la memoria y compruebe el número de clases. Se esperan 50 elementos de cada tipo de Iris. Asegúrese de especificar la ubicación del conjunto de datos en el equipo.

Agregue el siguiente código al archivo 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()) 

Cuando se ejecuta este código, la salida esperada es la siguiente:

Para poder usar el conjunto de datos y entrenar el modelo, es necesario definir la entrada y la salida. La entrada incluye 150 líneas de características y la salida es la columna de tipo de Iris. La red neuronal que usaremos requiere variables numéricas, por lo que la variable de salida se convertirá a un formato numérico.

4. Cree una columna en el conjunto de datos que representará la salida en un formato numérico y defina una entrada y salida de regresión.

Agregue el siguiente código al archivo 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()) 

Cuando se ejecuta este código, la salida esperada es la siguiente:

Para entrenar el modelo, es necesario convertir la entrada y salida del modelo al formato Tensor:

5. Convertir a Tensor:

Agregue el siguiente código al archivo 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 

Si ejecutamos el código, la salida esperada mostrará el formato de entrada y salida, como se muestra a continuación:

Hay 150 valores de entrada. Aproximadamente el 60 % serán datos de entrenamiento del modelo. Mantendrá el 20 % para la validación y el 30 % para una prueba.

En este tutorial, el tamaño de lote para un conjunto de datos de entrenamiento está definido en 10. Hay 95 elementos en el conjunto de entrenamiento, lo que significa que, en promedio, hay 9 lotes completos para recorrer en iteración el conjunto de entrenamiento una vez (una época). Mantendrá el tamaño de lote de los conjuntos de pruebas y validación en 1.

6. Divida los datos en conjuntos de entrenamiento, validación y prueba:

Agregue el siguiente código al archivo 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)

Pasos siguientes

Con los datos listos para usar, es el momento de entrenar nuestro modelo de PyTorch.