Estás leyendo la publicación: Guía paso a paso para construir una red neuronal simple en PyTorch desde cero
PyTorch es una de las bibliotecas más utilizadas para construir modelos de aprendizaje profundo, especialmente modelos basados en redes neuronales. En muchas tareas relacionadas con el aprendizaje profundo, encontramos el uso de PyTorch debido a sus características y capacidades, como preparación para la producción, capacitación distribuida, ecosistema sólido y compatibilidad con la nube. En este artículo, aprenderemos cómo podemos construir una red neuronal simple utilizando la biblioteca PyTorch en solo unos pocos pasos. Para este propósito, demostraremos una implementación práctica donde construiremos una red neuronal simple para un problema de clasificación.
Realizaremos esta implementación en los siguientes pasos:-
- Paso 1: Creando los datos
- Paso 2: Cargando los datos usando el cargador de datos
- Paso 3: Construcción de un modelo de red neuronal
- Definición de la clase de red neuronal
- Instanciando el clasificador
- Etapa 4: Entrenamiento del modelo de red neuronal
- Optimización de la curva de pérdida
- Definición de límites de decisión
- Paso 5: Haciendo predicciones
Comencemos con el primer paso, donde crearemos un conjunto de datos para la implementación.
Paso 1: Crear los datos
En este artículo, entenderemos la intuición detrás de definir y trabajar las redes neuronales en PyTorch. Para ello, construiremos una red neuronal desde cero y la aplicaremos a un problema de clasificación. Para este propósito, crearemos un conjunto de datos utilizando make_classification en sklearn.datasets que usaremos para crear un conjunto de datos de clasificación.
Usando las siguientes líneas de código, podemos crear el conjunto de datos para la clasificación:
from sklearn.datasets import make_classification X, Y = make_classification( n_features=4, n_redundant=0, n_informative=3, n_clusters_per_class=2, n_classes=3 )
Usando el código anterior, hemos creado un conjunto de datos para la clasificación en el que tenemos 4 características con 3 características informativas y 3 clases.
Visualicemos el conjunto de datos.
import matplotlib.pyplot as plt plt.title(“Datos multiclase, 4 funciones informativas, 3 clases”, fontsize=”grande”) plt.scatter(X[:, 0]X[:, 1]marcador=”o”, c=Y, s=25, edgecolor=”k”)
Aquí podemos ver nuestro conjunto de datos en un espacio bidimensional y los puntos son claramente visibles desde tres clases.
Después de crear el conjunto de datos, estamos listos para construir un modelo de clasificación. Dado que en este artículo, estamos discutiendo una implementación simple de una red neuronal usando PyTorch, usaremos una red neuronal de dos capas donde podemos usar sigmoid como nuestra función de activación. Los puntos de datos en el gráfico anterior serán nuestras coordenadas de entrada y las clases relacionadas con los puntos son la realidad fundamental.
Paso 2: Cargar los datos usando el cargador de datos
Antes de definir el modelo, debemos dividir nuestro conjunto de datos en pruebas y conjuntos de trenes. Eso se puede hacer usando las siguientes líneas de códigos.
from sklearn.model_selection import train_test_split X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.33, random_state=42)
Verifiquemos la forma del conjunto de datos dividido.
X_tren.forma, X_prueba.forma, Y_tren.forma, Y_prueba.forma
Producción:
Después de esto, debemos definir los datos del tren como un tensor PyTorch.
import antorcha Y_test = antorcha.from_numpy(X_test) Y_test = antorcha.from_numpy(np.asarray(Y_test))
Para usar los lotes del conjunto de datos, debemos pasar los datos a través del módulo Dataloader de PyTorch. Usando las siguientes líneas de código podemos hacer eso.
from torch.utils.data import Dataset, clase DataLoader Data(Dataset): def __init__(self): self.X=torch.from_numpy(X_train) self.Y=torch.from_numpy(Y_train) self.len=self.X. forma[0]
def __getitem__(self,index): return self.X[index]auto.Y[index]
def __len__(self): return self.len data=Data() loader=DataLoader(dataset=data,batch_size=64)
Comprobación de la forma de los datos bajo el tensor.
imprimir(datos.X[0:5]) print(datos.X.forma) print(datos.Y[0:5]) imprimir (datos.Y.forma)
Producción:
Paso 3: Construcción de un modelo de red neuronal
En primer lugar, definiremos las dimensiones de la red.
input_dim=4 # cuántas variables hay en el conjunto de datos hidden_dim = 25 # capas ocultas output_dim=3 # número de clases
Paso 3.1: Definición de la clase de red neuronal
Se puede definir una clase para crear redes simples utilizando las siguientes líneas de códigos.
import torch.nn como nn class Net(nn.Module): def __init__(self,input,H,output): super(Net,self).__init__() self.linear1=nn.Linear(input,H) self. linear2=nn.Linear(H,output) def adelante(self,x): x=torch.sigmoid(self.linear1(x)) x=self.linear2(x) return x
Paso 3.2: Crear una instancia del clasificador
Ahora, con las dimensiones definidas anteriormente, podemos instanciar una instancia de modelo utilizando la clase definida en el último paso.
clf=Neto(entrada_dim,hidden_dim,salida_dim)
Vamos a comprobar la información sobre el modelo.
imprimir(clf.parámetros)
Producción:
Aquí podemos ver que el modelo que hemos preparado tomará 4 características como entrada y dará 4 características como salida.
Paso 4: Entrenamiento del modelo de red neuronal
Antes del entrenamiento, debemos definir el criterio para calcular gradientes de parámetros y optimizadores para actualizar los parámetros.
criterio=nn.CrossEntropyLoss() Optimizer=torch.optim.SGD(clf.parameters(), lr=0.1)
Después de definir el criterio y el optimizador, estamos listos para entrenar nuestro modelo. Usando las siguientes líneas de códigos podemos entrenarlo.
tasa_de_aprendizaje = 1e-1 lista_de_perdidas = []
for t in range(1000): y_pred = clf(x) loss = criterio(y_pred, y) loss_list.append(loss.item()) clf.zero_grad() loss.backward() with torch.no_grad(): for param en clf.parameters(): param -= tasa_de_aprendizaje * param.grad
En este entrenamiento, hemos definido métodos que llevarán el gradiente acumulado a cero, agregarán la pérdida en loss_list, obtendrán un nuevo gradiente y actualizarán los parámetros usando la propagación hacia atrás.
Paso 4.1: Optimización de la curva de pérdida
La curva de pérdida nos permitirá conocer el rendimiento del modelo.
Visualización de la curva de pérdida
paso = np.linspace(0,1000,1000) plt.plot(paso,np.array(loss_list))
Producción:
En el resultado anterior, podemos ver que nuestra curva de pérdidas convergió y, utilizando este modelo, también podemos definir nuestros límites de decisión.
Paso 4.2: Definición de los límites de decisión
params = list(clf.parameters()) w = params[0].separar().numpy()[0]
b = parámetros[1].separar().numpy()[0]
t = parámetros[3].separar().numpy()[0]
plt.dispersión(X[:, 0]X[:, 1]c=Y,cmap=’jet’) u = np.linspace(X[:, 0].min(), X[:, 0].max(), 2) plt.plot(u, (0.5-bw[0]*u)/w[1]) plt.plot(u, (0.5-tw[0]*u)/w[1]) plt.xlim(X[:, 0].min()-0.5, X[:, 0].max()+0.5) plt.ylim(X[:, 1].min()-0.5, X[:, 1].máx()+0.5)
Producción:
En el resultado anterior, podemos ver que hemos definido nuestros límites de decisión y se ve bien. Ahora podemos usar el modelo para hacer predicciones.
Haciendo predicciones
Hagamos las predicciones con la red neuronal entrenada.
x_val = antorcha.from_numpy(X_test) z=clf(x_val) yhat=torch.max(z.data,1) yhat[1]
Producción:
En el resultado anterior, podemos ver las predicciones de las etiquetas de clase de los patrones de entrada dados. Usando algunas de las modificaciones, como el número de capas o el número de épocas, podemos mejorar el rendimiento de nuestro modelo.
Ultimas palabras
En este artículo, hemos aprendido cómo definir una red neuronal en PyTorch en solo unos pocos pasos. Hemos definido un conjunto de datos sobre el que hemos entrenado una red neuronal de doble capa. Hemos utilizado esta red para la clasificación y la hemos implementado en PyTorch. Esto también puede ser un ejemplo de una red neuronal de clasificación multiclase simple.
