Create app.py

app.py

@@ -0,0 +1,140 @@
+import streamlit as st
+import yfinance as yf
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from datetime import datetime
+from sklearn.preprocessing import MinMaxScaler
+
+# Crear y entrenar el modelo
+def train_model(x_train, y_train, input_size, prediction_days, dim_feedforward, epochs=100):
+    class Transformer(nn.Module):
+        def __init__(self, input_size, prediction_days, dim_feedforward):
+            super(Transformer, self).__init__()
+            self.input_size = input_size
+            self.fc1 = nn.Linear(input_size, dim_feedforward)
+            self.fc2 = nn.Linear(dim_feedforward, dim_feedforward * 2)
+            self.fc3 = nn.Linear(dim_feedforward * 2, dim_feedforward * 4)
+            self.fc4 = nn.Linear(dim_feedforward * 4, dim_feedforward * 8)
+            self.fc5 = nn.Linear(dim_feedforward * 8, dim_feedforward * 16)
+            self.fc6 = nn.Linear(dim_feedforward * 16, dim_feedforward * 32)
+            self.fc7 = nn.Linear(dim_feedforward * 32, dim_feedforward * 64)
+            self.fc8 = nn.Linear(dim_feedforward * 64, dim_feedforward * 128)
+            self.fc9 = nn.Linear(dim_feedforward * 128, dim_feedforward * 256)
+            self.fc10 = nn.Linear(dim_feedforward * 256, prediction_days)
+            self.dropout = nn.Dropout(0.2)
+ 
+        def forward(self, x):
+            x = x.reshape(-1, self.input_size)
+            x = self.fc1(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc2(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc3(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc4(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc5(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc6(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc7(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc8(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc9(x)
+            x = nn.functional.relu(x)
+            x = self.dropout(x)
+            x = self.fc10(x)
+
+            return x
+    
+
+    model = Transformer(input_size=input_size, prediction_days=1, dim_feedforward=dim_feedforward)
+    criterion = nn.MSELoss()
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+    for epoch in range(epochs):
+        inputs = torch.from_numpy(x_train).float()
+        labels = torch.from_numpy(y_train).float().unsqueeze(1)
+
+        # Limpiando los gradientes
+        optimizer.zero_grad()
+
+        # Forward
+        outputs = model(inputs)
+        loss = criterion(outputs, labels)
+
+        # Backward y optimización
+        loss.backward()
+        optimizer.step()
+
+        if (epoch + 1) % 10 == 0:
+            st.write("Epoch: {}/{} | Loss: {:.4f}".format(epoch + 1, epochs, loss.item()))
+
+    return model
+
+# Página principal
+st.title("Stock Price Prediction")
+
+# Interfaz para ingresar el ticket de la empresa
+company = st.text_input("Enter the company ticket:")
+
+# Interfaz para ingresar la cantidad de días a predecir
+prediction_days = st.slider("Enter the number of days to predict:", min_value=1, max_value=30, value=7)
+
+# Botón para iniciar el entrenamiento
+if st.button("Start Training"):
+    # Descarga de datos históricos de la compañía deseada
+    ticker = yf.Ticker(company)
+    hist = ticker.history(start="2015-01-01", end=datetime.now())
+
+    # Escalando los datos
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    scaled_data = scaler.fit_transform(hist["Close"].values.reshape(-1, 1))
+
+    # Creando el conjunto de entrenamiento
+    x_train = []
+    y_train = []
+
+    for i in range(prediction_days, len(scaled_data)):
+        x_train.append(scaled_data[i - prediction_days : i, 0])
+        y_train.append(scaled_data[i, 0])
+
+    x_train, y_train = np.array(x_train), np.array(y_train)
+    x_train = np.reshape(x_train, (x_train.shape[0], prediction_days))
+
+    # Entrenar el modelo
+    trained_model = train_model(x_train, y_train, input_size=x_train.shape[1], prediction_days=1, dim_feedforward=21)
+
+    # Predicción
+    future_prediction = []
+    last_x = scaled_data[-prediction_days:]
+
+    for i in range(prediction_days):
+        future_input = torch.from_numpy(last_x).float().reshape(1, prediction_days)
+        future_price = trained_model(future_input)
+        future_prediction.append(future_price.detach().numpy()[0][0])
+        last_x = np.append(last_x[1:], future_price.detach().numpy().reshape(-1, 1))
+
+    # Desescalando los resultados
+    prediction = scaler.inverse_transform(np.array(future_prediction).reshape(-1, 1))
+
+    # Imprimiendo los resultados
+    st.subheader("Predictions:")
+    for i, price in enumerate(prediction):
+        st.write("Day {}: {:.2f}".format(i + 1, price[0]))
+
+    # Botón de reinicio
+    if st.button("Reset"):
+        st.experimental_rerun()