Update app.py

app.py

@@ -59,11 +59,37 @@ class LSTM(nn.Module):
         out = self.fc(out[:, -1, :])
         return out
 
+#CLASE GRU
+class GRU(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers, output_size):
+        super(GRU, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True)
+        self.fc = nn.Linear(hidden_size, output_size)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.3)  # Dropout para regularización
+
+        # Inicialización de los pesos de la capa lineal
+        nn.init.xavier_normal_(self.fc.weight)
+
+    def forward(self, x):
+        # Inicialización de los estados ocultos
+        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
+
+        # Propagación a través de la capa GRU
+        out, _ = self.gru(x, h0)
+
+        # Última capa GRU
+        out = self.fc(out[:, -1, :])
+
+        return out
+
 st.title('Predicción de Series de Tiempo')
 st.sidebar.title('Parámetros del Modelo')
 
 model_type = st.sidebar.selectbox('Selecciona el modelo', ('LSTM', 'Otro Modelo'))
-num_epochs = st.sidebar.slider('Número de épocas', 100, 500, 200)
+num_epochs = st.sidebar.slider('Número de épocas', 100, 200)
 # learning_rate = st.sidebar.number_input('Tasa de aprendizaje', 0.001, 0.1, 0.01, 0.001)
 
 if model_type == 'LSTM':
@@ -75,7 +101,7 @@ if model_type == 'LSTM':
     model = LSTM(input_size, hidden_size, num_layers, output_size)
 
     criterion = nn.MSELoss()
-    # optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
 
     if st.sidebar.button('Entrenar y Predecir'):
         for epoch in range(num_epochs):
@@ -129,3 +155,54 @@ if model_type == 'LSTM':
         # ax.legend()
         # ax.grid(True)
         # st.pyplot(fig)
+else :
+    input_size = 1
+    hidden_size = 50
+    num_layers = 2
+    output_size = 1
+
+    model = GRU(input_size, hidden_size, num_layers, output_size)
+
+    criterion = nn.MSELoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+    if st.sidebar.button('Entrenar y Predecir'):
+        for epoch in range(num_epochs):
+            model.train()
+            outputs = model(trainX)
+            optimizer.zero_grad()
+            loss = criterion(outputs, trainY)
+            loss.backward()
+            optimizer.step()
+            if (epoch+1) % 100 == 0:
+                st.write(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
+
+        model.eval()
+        train_predict = model(trainX)
+        test_predict = model(testX)
+
+        train_predict = scaler.inverse_transform(train_predict.detach().numpy().reshape(-1, 1))
+        trainY_plot = scaler.inverse_transform(trainY.numpy().reshape(-1, 1))
+        test_predict = scaler.inverse_transform(test_predict.detach().numpy().reshape(-1, 1))
+        testY_plot = scaler.inverse_transform(testY.numpy().reshape(-1, 1))
+
+        train_data = pd.DataFrame({
+            'Fecha': filtered_data1['FECHA'].values[seq_length:seq_length+len(trainY)],
+            'Datos de entrenamiento': trainY_plot.ravel(),
+            'Predicciones de entrenamiento': train_predict.ravel()
+        })
+    
+        test_data = pd.DataFrame({
+            'Fecha': filtered_data2['FECHA'].values[seq_length:seq_length+len(testY)],
+            'Datos de prueba': testY_plot.ravel(),
+            'Predicciones de prueba': test_predict.ravel()
+        })
+    
+        # Concatenar los datos para tener una sola tabla
+        combined_data = pd.concat([train_data, test_data])
+    
+        # Ajustar el índice
+        combined_data.set_index('Fecha', inplace=True)
+    
+        # Mostrar la gráfica en Streamlit
+        st.line_chart(combined_data)