Saltar al contenido

Análisis predictivo con PyTorch

Ha creado el tren y los juegos de prueba y está listo para entrenar al modelo. Empezarás importando las bibliotecas necesarias para trabajar con la biblioteca de Pytorch.

12345importar antorchaimportar antorcha.utils.dataimportar antorcha.nn como nnimportar antorcha.nn.funcional como Ffrom antorcha.autograd import Variable

pitón

Análisis predictivo con PyTorch
Análisis predictivo con PyTorch

Está todo listo para construir el modelo predictivo usando el algoritmo de la Red Neural Artificial (o RNA). La arquitectura básica de una RNA consiste en tres componentes principales.

  1. Capa de entrada: Aquí es donde se alimentan las observaciones de entrenamiento.
  2. Capas ocultas: Son las capas intermedias entre las capas de entrada y salida. El modelo aprende acerca de las relaciones involucradas en los datos de estas capas.
  3. Capa de salida: Esta es la capa donde se extrae el resultado final de lo que ocurre en las capas anteriores.

El primer paso para crear el modelo RNA es crear una clase, RNA, que herede de la clase nn.Module. El siguiente paso es definir las capas de la red mediante el método __init__().

En este caso, el modelo tiene cuatro capas. Cada capa esperará que el primer parámetro sea el tamaño de entrada, que en este caso es de siete. Repetirás el proceso para las capas restantes. El único cambio en la última etapa será que la salida es una variable, que representa la columna de destino. También añadirá una capa de salida para evitar la sobrecarga.

Una vez que hayas definido las capas, entonces define cómo interactúan entre sí con la función def forward(self, x), como se muestra a continuación. Esto significa que estás construyendo una red neuronal completamente conectada, que va de la entrada a la salida de una manera directa. El paso adelante comienza con la función de activación relu , o Activación Lineal Rectificada.

Para la capa de salida, usarás la función sigmoide para convertir las probabilidades a las clases uno y cero.

12345678910111213141516171819classANN(nn.Module):def__init__(self, input_dim =7, output_dim =1):super(ANN, self). __init__() self.fc1 = nn.Lineal(input_dim,64) self.fc2 = nn.Lineal(64,64) self.fc3 = nn.Lineal(64,32) self.fc4 = nn.Lineal(32,32) self. capa_de_salida = nn.Lineal(32,1) self.dropout = nn.Dropout(0,15)defforward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self. fc2(x)) x = self.dropout(x) x = F.relu(self.fc3(x)) x = F.relu(self.fc4(x)) x = self.output_layer(x)return nn.Sigmoid()(x)

pitón

Ahora que has definido la arquitectura del modelo arriba, instancializa el modelo usando el código de abajo.

123model = ANN(input_dim =7, output_dim =1)print(model)

pitón

Salida:

12345678ANN( (fc1): Lineal(in_features=7, out_features=64, bias=True) (fc2): Lineal(in_features=64, out_features=64, bias=True) (fc3): Lineal(in_features=64, out_features=32, sesgo=Verdad) (fc4): Lineal(in_features=32, out_features=32, bias=True) (capa_de_salida): Lineal(in_features=32, out_features=1, bias=True) (abandono): Dropout(p=0.2, inplace=Falso) )

Has creado el modelo, y ahora tienes que preparar los datos para la biblioteca de Pytorch. Las líneas de código de abajo llevan a cabo la conversión en el tren y las matrices de prueba.

123456X_train = torch.from_numpy(X_train)y_train = torch.from_numpy(y_train).view(-1,1)X_test = torch.from_numpy(X_test)y_test = torch.from_numpy(y_test).view(-1,1)

pitón

El siguiente paso es hacer que estos datos sean iterables. En términos simples, esto significa que el modelo iterará sobre el conjunto de datos para generar predicciones. Utilizará la API de torch.utils proporcionada por Pytorch para realizar esta tarea, como se muestra a continuación.

12345train = antorcha.utils.datos.TensorDataset(X_train,y_train)test = antorcha.utils.datos.TensorDataset(X_test,y_test)train_loader = antorcha. utils.data.DataLoader(train, batch_size =64, shuffle =True)test_loader = torch.utils.data.DataLoader(test, batch_size =64, shuffle =True)

pitón