Spaces:
Sleeping
Sleeping
import streamlit as st | |
import pandas as pd | |
import numpy as np | |
import torch | |
import torch.nn as nn | |
import matplotlib.pyplot as plt | |
from sklearn.preprocessing import MinMaxScaler | |
# Cargar los datos de los dos CSV | |
file1 = 'PARCIAL-AGUA-_2_.csv' | |
file2 = 'PARCIAL-AGUA-_3_.csv' | |
data1 = pd.read_csv(file1) | |
data2 = pd.read_csv(file2) | |
# Convertir la columna 'FECHA' a objetos datetime y filtrar por años | |
data1['FECHA'] = pd.to_datetime(data1['FECHA']) | |
data2['FECHA'] = pd.to_datetime(data2['FECHA']) | |
filtered_data1 = data1[data1['FECHA'].dt.year >= 2007] | |
filtered_data2 = data2[data2['FECHA'].dt.year >= 2007] | |
combined_values = np.concatenate([filtered_data1['VALOR-LS-CF-N'].values, filtered_data2['VALOR-LS-CF-N'].values]).reshape(-1, 1) | |
scaler = MinMaxScaler() | |
scaled_values = scaler.fit_transform(combined_values) | |
scaled_values1 = scaled_values[:len(filtered_data1)] | |
scaled_values2 = scaled_values[len(filtered_data1):] | |
def sliding_windows(data, seq_length): | |
x, y = [], [] | |
for i in range(len(data) - seq_length): | |
x.append(data[i:i + seq_length]) | |
y.append(data[i + seq_length]) | |
return np.array(x), np.array(y) | |
seq_length = 4 | |
x_train, y_train = sliding_windows(scaled_values1, seq_length) | |
x_test, y_test = sliding_windows(scaled_values2, seq_length) | |
trainX = torch.Tensor(x_train) | |
trainY = torch.Tensor(y_train) | |
testX = torch.Tensor(x_test) | |
testY = torch.Tensor(y_test) | |
class LSTM(nn.Module): | |
def __init__(self, input_size, hidden_size, num_layers, output_size): | |
super(LSTM, self).__init__() | |
self.hidden_size = hidden_size | |
self.num_layers = num_layers | |
self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) | |
self.fc = nn.Linear(hidden_size, output_size) | |
def forward(self, x): | |
h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size) | |
c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size) | |
out, _ = self.lstm(x, (h0, c0)) | |
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) | |
learning_rate = st.sidebar.number_input('Tasa de aprendizaje', 0.001, 0.1, 0.01, 0.001) | |
if model_type == 'LSTM': | |
input_size = 1 | |
hidden_size = 50 | |
num_layers = 2 | |
output_size = 1 | |
model = LSTM(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, | |
'Predicciones de entrenamiento': train_predict | |
}) | |
test_data = pd.DataFrame({ | |
'Fecha': filtered_data2['FECHA'].values[seq_length:seq_length+len(testY)], | |
'Datos de prueba': testY_plot, | |
'Predicciones de prueba': test_predict | |
}) | |
# 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) | |
# fig, ax = plt.subplots(figsize=(12, 6)) | |
# ax.plot(filtered_data1['FECHA'].values[seq_length:seq_length+len(trainY)], trainY_plot, label='Datos de entrenamiento') | |
# ax.plot(filtered_data1['FECHA'].values[seq_length:seq_length+len(trainY)], train_predict, label='Predicciones de entrenamiento') | |
# ax.plot(filtered_data2['FECHA'].values[seq_length:seq_length+len(testY)], testY_plot, label='Datos de prueba') | |
# ax.plot(filtered_data2['FECHA'].values[seq_length:seq_length+len(testY)], test_predict, label='Predicciones de prueba') | |
# ax.set_xlabel('Fecha') | |
# ax.set_ylabel('VALOR-LS-CF-N') | |
# ax.set_title('Predicciones con LSTM') | |
# ax.legend() | |
# ax.grid(True) | |
# st.pyplot(fig) | |