Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,189 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.metrics import mean_squared_error
+import plotly.graph_objects as go
+from datetime import date, timedelta
+
+# --- CONFIGURATION ---
+st.set_page_config(layout="wide", page_title="AI Stock Predictor")
+
+# --- UI HEADER ---
+st.title("📈 Neural Network Stock Predictor")
+st.markdown("""
+This app uses a **Long Short-Term Memory (LSTM)** neural network to predict stock prices. 
+It first **simulates** the model against the last year's data to verify accuracy, then predicts the future.
+""")
+
+# --- SIDEBAR DASHBOARD ---
+st.sidebar.header("Configuration")
+ticker = st.sidebar.text_input("Enter Ticker Symbol", value="^IXIC") # Default to NASDAQ
+st.sidebar.caption("Examples: ^IXIC (Nasdaq), AAPL, TSLA, BTC-USD")
+
+horizon_option = st.sidebar.selectbox(
+    "Prediction Horizon", 
+    ("Next Day", "Next Week", "Next Month", "Next Year")
+)
+
+# Map horizon to days
+horizon_mapping = {
+    "Next Day": 1,
+    "Next Week": 7,
+    "Next Month": 30,
+    "Next Year": 365
+}
+forecast_days = horizon_mapping[horizon_option]
+
+# --- FUNCTIONS ---
+
+@st.cache_data
+def load_data(symbol):
+    """Fetches data from yfinance. We fetch 5 years to ensure enough training data."""
+    start_date = date.today() - timedelta(days=5*365)
+    data = yf.download(symbol, start=start_date, end=date.today())
+    data.reset_index(inplace=True)
+    return data
+
+def create_dataset(dataset, look_back=60):
+    """Converts array of values into a dataset matrix for LSTM."""
+    dataX, dataY = [], []
+    for i in range(len(dataset) - look_back - 1):
+        a = dataset[i:(i + look_back), 0]
+        dataX.append(a)
+        dataY.append(dataset[i + look_back, 0])
+    return np.array(dataX), np.array(dataY)
+
+def train_lstm_model(train_data, look_back=60):
+    """Builds and trains the LSTM Neural Network."""
+    # Reshape input to be [samples, time steps, features]
+    X_train, y_train = create_dataset(train_data, look_back)
+    X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))
+    
+    # Build LSTM Architecture
+    model = Sequential()
+    model.add(LSTM(50, return_sequences=True, input_shape=(look_back, 1)))
+    model.add(LSTM(50, return_sequences=False))
+    model.add(Dense(25))
+    model.add(Dense(1)) # Output layer
+    
+    model.compile(optimizer='adam', loss='mean_squared_error')
+    
+    # Train (Epochs=1 is used here for speed in demo, increase to 20-50 for real accuracy)
+    model.fit(X_train, y_train, batch_size=1, epochs=1, verbose=0)
+    return model
+
+# --- MAIN EXECUTION ---
+
+data_load_state = st.text('Loading data...')
+try:
+    data = load_data(ticker)
+    data_load_state.text('Loading data... done!')
+except Exception as e:
+    st.error(f"Error loading data: {e}")
+    st.stop()
+
+if len(data) < 500:
+    st.error("Not enough data to train the model. Please choose a stock with deeper history.")
+    st.stop()
+
+# Prepare Data
+df_close = data[['Close']].values
+scaler = MinMaxScaler(feature_range=(0, 1))
+scaled_data = scaler.fit_transform(df_close)
+
+# --- SIMULATION (BACKTESTING) ---
+st.subheader("1. Simulation: Testing against Last Year")
+st.write("Training model on past data to verify performance on the last 365 days...")
+
+# Split data: Train on everything BEFORE the last 365 days, Test on LAST 365 days
+training_len = len(scaled_data) - 365
+train_data = scaled_data[0:training_len, :]
+test_data = scaled_data[training_len - 60:, :] # -60 to handle look_back
+
+# Train Model
+with st.spinner('Training Neural Network... (This may take a moment)'):
+    model = train_lstm_model(train_data)
+
+# Predict on the "Last Year" (Simulation)
+x_test = []
+look_back = 60
+for i in range(60, len(test_data)):
+    x_test.append(test_data[i-60:i, 0])
+x_test = np.array(x_test)
+x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
+
+predictions = model.predict(x_test)
+predictions = scaler.inverse_transform(predictions) # Scale back to normal price
+
+# Calculate Accuracy (RMSE)
+valid_set = data[training_len:]
+valid_set['Predictions'] = predictions
+rmse = np.sqrt(np.mean(((predictions - valid_set['Close'].values) ** 2)))
+
+# Calculate Directional Accuracy (Did it go up/down correctly?)
+valid_set['Actual_Change'] = valid_set['Close'].diff()
+valid_set['Pred_Change'] = valid_set['Predictions'].diff()
+valid_set['Correct_Direction'] = np.sign(valid_set['Actual_Change']) == np.sign(valid_set['Pred_Change'])
+accuracy_score = valid_set['Correct_Direction'].mean() * 100
+
+col1, col2 = st.columns(2)
+col1.metric("Simulation RMSE (Price Error)", f"{rmse:.2f}")
+col2.metric("Directional Accuracy", f"{accuracy_score:.2f}%")
+
+if accuracy_score > 50:
+    st.success(f"Model passed simulation with {accuracy_score:.1f}% directional accuracy.")
+else:
+    st.warning(f"Model accuracy is low ({accuracy_score:.1f}%). Stock markets are volatile!")
+
+# Plot Simulation
+fig_sim = go.Figure()
+fig_sim.add_trace(go.Scatter(x=data['Date'][:training_len], y=data['Close'][:training_len].values.flatten(), mode='lines', name='Training Data'))
+fig_sim.add_trace(go.Scatter(x=valid_set['Date'], y=valid_set['Close'].values.flatten(), mode='lines', name='Actual Price (Last Year)'))
+fig_sim.add_trace(go.Scatter(x=valid_set['Date'], y=valid_set['Predictions'].values.flatten(), mode='lines', name='AI Prediction (Simulation)', line=dict(dash='dot', color='orange')))
+st.plotly_chart(fig_sim, use_container_width=True)
+
+
+# --- FUTURE PREDICTION ---
+st.markdown("---")
+st.subheader(f"2. Future Forecast: {horizon_option}")
+
+# Retrain model on ALL data for best future prediction
+with st.spinner('Refining model with full data for future prediction...'):
+    full_model = train_lstm_model(scaled_data)
+
+# Predict Future Steps
+# We start with the last 60 days of known data
+last_60_days = scaled_data[-60:]
+current_batch = last_60_days.reshape((1, 60, 1))
+future_predictions = []
+
+for i in range(forecast_days):
+    # Get prediction (scaled)
+    current_pred = full_model.predict(current_batch)[0]
+    future_predictions.append(current_pred)
+    
+    # Update batch to include new prediction, remove oldest day
+    current_pred_reshaped = current_pred.reshape((1, 1, 1))
+    current_batch = np.append(current_batch[:, 1:, :], current_pred_reshaped, axis=1)
+
+# Inverse transform to get real prices
+future_predictions = scaler.inverse_transform(future_predictions)
+
+# Create Future Dates
+last_date = data['Date'].iloc[-1]
+future_dates = [last_date + timedelta(days=x) for x in range(1, forecast_days + 1)]
+
+# Plot Future
+fig_future = go.Figure()
+# Show last 365 days of context
+fig_future.add_trace(go.Scatter(x=data['Date'][-365:], y=data['Close'][-365:].values.flatten(), mode='lines', name='Historical Close (Last Year)'))
+fig_future.add_trace(go.Scatter(x=future_dates, y=future_predictions.flatten(), mode='lines', name='AI Future Prediction', line=dict(dash='dot', color='green', width=3)))
+fig_future.update_layout(title=f"Prediction for next {forecast_days} days")
+st.plotly_chart(fig_future, use_container_width=True)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.write("Note: Long-term predictions (Year) usually revert to a trend line as error accumulates. Short-term (Day/Week) is generally more reliable.")