Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,9 +1,396 @@
+# import streamlit as st
+# import pandas as pd
+# import numpy as np
+# import torch
+# from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForCausalLM
+# from peft import PeftModel
+# from sklearn.linear_model import LinearRegression
+# from sklearn.model_selection import train_test_split
+# from sklearn.metrics import mean_squared_error, r2_score
+# import matplotlib.pyplot as plt
+
+# # Set page configuration
+# st.set_page_config(layout="wide", page_title="FinGPT Investment Predictor")
+
+# # --- Part 1: Financial Sentiment Analysis Model Loading and Function ---
+
+# # Use st.cache_resource to load heavy models only once
+# @st.cache_resource
+# def load_sentiment_model(sentiment_model_name="FinGPT/fingpt-sentiment_llama2-13b_lora", 
+#                          base_tokenizer_name="meta-llama/Llama-2-13b-chat-hf"): # Added base_tokenizer_name
+#     """
+#     Loads the pre-trained sentiment analysis model and tokenizer.
+#     Uses st.cache_resource to prevent reloading on every Streamlit rerun.
+#     """
+#     st.write(f"Loading sentiment tokenizer from base model: {base_tokenizer_name}...")
+#     tokenizer = AutoTokenizer.from_pretrained(base_tokenizer_name) # Load tokenizer from base Llama model
+
+#     st.write(f"Loading sentiment model: {sentiment_model_name}...")
+#     # Load the sentiment model (which is the LoRA adapter)
+#     model = AutoModelForSequenceClassification.from_pretrained(sentiment_model_name)
+#     model.eval() # Set model to evaluation mode
+#     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+#     model.to(device)
+#     st.write(f"Sentiment model loaded. Using device: {device}")
+#     return tokenizer, model, device
+
+# tokenizer, sentiment_model, device = load_sentiment_model()
+
+# def get_sentiment_score_and_label(text):
+#     """
+#     Analyzes the sentiment of the given text using the loaded model.
+#     Returns a numerical score (-1 to 1) and a categorical label (negative/neutral/positive).
+#     """
+#     inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True).to(device)
+#     with torch.no_grad():
+#         outputs = sentiment_model(**inputs)
+#         logits = outputs.logits
+    
+#     probabilities = torch.softmax(logits, dim=1).cpu().numpy()[0]
+    
+#     # Assuming the FinGPT sentiment model outputs logits in the order: [negative, neutral, positive].
+#     neg_score = probabilities[0]
+#     neu_score = probabilities[1]
+#     pos_score = probabilities[2]
+    
+#     # A simple weighted average to get a single sentiment score between -1 and 1
+#     sentiment_score = (pos_score * 1) + (neg_score * -1) + (neu_score * 0) 
+    
+#     labels = ["negative", "neutral", "positive"]
+#     predicted_class_id = logits.argmax().item()
+#     predicted_label = labels[predicted_class_id]
+    
+#     return sentiment_score, predicted_label
+
+# # --- Part 2: Simulate Financial Data and Train Prediction Model ---
+
+# # Use st.cache_data to run data generation and model training only once
+# @st.cache_data
+# def prepare_data_and_train_model():
+#     """
+#     Simulates historical financial data, calculates sentiment,
+#     and trains a simple linear regression model.
+#     """
+#     st.write("Simulating financial data and training prediction model...")
+#     # Let's create some dummy historical data for a stock and news headlines
+#     dates = pd.to_datetime(pd.date_range(start='2024-01-01', periods=60, freq='D')) # Increased period for better visualization
+#     np.random.seed(42) # for reproducibility
+
+#     # Simulate stock prices with some trend and noise
+#     base_price = 100
+#     prices = [base_price + np.random.uniform(-2, 2)]
+#     for _ in range(1, len(dates)):
+#         change = np.random.uniform(-1, 1) + (np.random.uniform(-0.5, 0.5) * np.random.choice([-1, 1], p=[0.2, 0.8])) 
+#         prices.append(prices[-1] + change)
+#     prices = np.array(prices) + np.cumsum(np.random.uniform(-0.1, 0.3, len(dates))) 
+
+#     # Simulate financial news headlines for each day
+#     dummy_news = [
+#         "Tech company reports strong Q4 earnings, stock up.",
+#         "Market shows signs of recovery after recent dip.",
+#         "Government announces new regulations affecting energy sector.",
+#         "Company X faces legal challenges, shares fall.",
+#         "Positive economic indicators boost investor confidence.",
+#         "Global supply chain issues continue to impact manufacturing.",
+#         "Innovation in AI drives new growth opportunities for company Z.",
+#         "Analyst downgrades stock, citing valuation concerns.",
+#         "Central bank holds interest rates steady, as expected.",
+#         "Surprise acquisition announced, boosting stock of target company.",
+#         "Quarterly sales below expectations, cautious outlook given.",
+#         "New product launch receives mixed reviews.",
+#         "Commodity prices stabilizing after volatile period.",
+#         "Major competitor announces expansion plans.",
+#         "Strong consumer spending data released.",
+#         "Company Y CEO resigns amidst controversy.",
+#         "Healthcare sector sees increased M&A activity.",
+#         "Inflation concerns persist, impacting consumer sentiment.",
+#         "Renewable energy stocks gain traction.",
+#         "Geopolitical tensions rise, market volatility increases.",
+#         "Positive clinical trial results for biotech firm.",
+#         "Earnings report beats estimates, stock rallies.",
+#         "Product recall announced, shares decline sharply.",
+#         "New trade agreement expected to benefit exporters.",
+#         "Tech giant invests heavily in R&D, future growth anticipated.",
+#         "Retail sales unexpectedly weak last month.",
+#         "Financial institution expands services, positive outlook.",
+#         "Mining company faces environmental penalties.",
+#         "Market sentiment remains cautiously optimistic.",
+#         "Dividend increase announced, attracting income investors.",
+#         "Breakthrough in medical research boosts pharma stock.",
+#         "New energy policy to impact utility companies.",
+#         "Cybersecurity firm reports major data breach.",
+#         "E-commerce sales exceed forecasts during holiday season.",
+#         "Automotive industry faces chip shortage challenges.",
+#         "Biotech startup secures significant funding.",
+#         "Real estate market shows signs of cooling.",
+#         "Investment bank upgrades rating for tech stock.",
+#         "Consumer confidence index reaches new high.",
+#         "Airline industry recovers strongly post-pandemic.",
+#         "Retailer announces store closures, stock drops.",
+#         "Software company acquires competitor, market reacts positively.",
+#         "Global trade tensions ease, positive for exporters.",
+#         "New environmental regulations impact manufacturing costs.",
+#         "Tourism sector sees strong rebound, hotel stocks rise.",
+#         "Bank reports solid profits despite economic headwinds.",
+#         "Construction firm wins major government contract.",
+#         "Food prices continue to rise, affecting grocery chains.",
+#         "Luxury brand sales surge in emerging markets.",
+#         "Telecommunications giant invests in 5G infrastructure."
+#     ]
+
+#     # Ensure we have enough news for all dates
+#     if len(dummy_news) < len(dates):
+#         dummy_news_extended = (dummy_news * (len(dates) // len(dummy_news) + 1))[:len(dates)]
+#     else:
+#         dummy_news_extended = dummy_news[:len(dates)]
+
+#     # Calculate sentiment scores for each day's news
+#     sentiment_scores = [get_sentiment_score_and_label(news)[0] for news in dummy_news_extended]
+
+#     # Create a DataFrame
+#     data = pd.DataFrame({
+#         'Date': dates,
+#         'Price': prices,
+#         'Sentiment': sentiment_scores,
+#         'News': dummy_news_extended 
+#     })
+#     data.set_index('Date', inplace=True)
+
+#     # Add lagged price and sentiment as features
+#     data['Previous_Day_Price'] = data['Price'].shift(1)
+#     data['Previous_Day_Sentiment'] = data['Sentiment'].shift(1)
+
+#     # Drop the first row which will have NaN due to shifting
+#     data.dropna(inplace=True)
+
+#     # We want to predict 'Price' based on 'Previous_Day_Price' and 'Previous_Day_Sentiment'
+#     X = data[['Previous_Day_Price', 'Previous_Day_Sentiment']]
+#     y = data['Price']
+
+#     # Split data into training and testing sets (chronologically)
+#     test_size_ratio = 0.2
+#     split_index = int(len(data) * (1 - test_size_ratio))
+#     X_train, X_test = X.iloc[:split_index], X.iloc[split_index:]
+#     y_train, y_test = y.iloc[:split_index], y.iloc[split_index:]
+
+#     # Initialize and train the Linear Regression model
+#     model_prediction = LinearRegression()
+#     model_prediction.fit(X_train, y_train)
+
+#     # Make predictions on the test set
+#     y_pred = model_prediction.predict(X_test)
+
+#     # Evaluate the model
+#     mse = mean_squared_error(y_test, y_pred)
+#     r2 = r2_score(y_test, y_pred)
+    
+#     return data, X_train, X_test, y_train, y_test, y_pred, model_prediction, mse, r2
+
+# # Run the data preparation and model training
+# data, X_train, X_test, y_train, y_test, y_pred, model_prediction, mse, r2 = prepare_data_and_train_model()
+
+# # --- Part 3: LLM Forecaster Model Loading and Function (Conceptual) ---
+
+# # Load the base Llama-2-7b-chat model (required by the LoRA adapter)
+# @st.cache_resource
+# def load_base_llm_model(base_model_name="meta-llama/Llama-2-7b-chat-hf"):
+#     """
+#     Loads the base Large Language Model required for the FinGPT forecaster.
+#     """
+#     st.write(f"Loading base LLM model: {base_model_name}...")
+#     base_tokenizer = AutoTokenizer.from_pretrained(base_model_name)
+#     base_model = AutoModelForCausalLM.from_pretrained(
+#         base_model_name,
+#         torch_dtype=torch.float16, # Use float16 for memory efficiency
+#         device_map="auto" # Automatically maps model to available devices (GPU if available)
+#     )
+#     return base_tokenizer, base_model
+
+# base_tokenizer, base_llm_model = load_base_llm_model()
+
+# @st.cache_resource
+# def load_forecaster_model(forecaster_model_name="FinGPT/fingpt-forecaster_dow30_llama2-7b_lora"):
+#     """
+#     Loads the FinGPT forecaster LoRA adapter and merges it with the base LLM.
+#     """
+#     st.write(f"Loading FinGPT forecaster model: {forecaster_model_name}...")
+#     # Load the LoRA adapter
+#     model = PeftModel.from_pretrained(base_llm_model, forecaster_model_name)
+#     model = model.eval()
+#     st.write(f"FinGPT forecaster model loaded.")
+#     return model
+
+# forecaster_llm_model = load_forecaster_model()
+
+# def get_llm_forecast(ticker, current_date, news_summary, current_price):
+#     """
+#     Generates a text-based forecast using the FinGPT forecaster LLM.
+#     This is a conceptual demonstration of LLM forecasting.
+#     """
+#     # Construct a prompt for the LLM forecaster
+#     # This prompt structure is simplified; real FinGPT forecasters might expect more complex inputs
+#     # based on their training data (e.g., historical data, financial statements).
+#     prompt = f"""
+#     You are a financial expert.
+#     Analyze the following information and provide a concise prediction for the stock price movement of {ticker} for the next week.
+    
+#     Current Date: {current_date.strftime('%Y-%m-%d')}
+#     Current Price of {ticker}: ${current_price:.2f}
+#     Recent News: "{news_summary}"
+    
+#     Based on this information, what is your prediction for {ticker}'s stock price movement next week? Provide a brief analysis.
+#     """
+    
+#     # For Llama-2-chat models, typically prompts are wrapped with specific tokens
+#     # This is a common format for instruction-tuned Llama models.
+#     chat_template = f"<s>[INST] {prompt} [/INST]"
+
+#     inputs = base_tokenizer(chat_template, return_tensors="pt").to(device)
+
+#     # Generate response from the LLM
+#     with torch.no_grad():
+#         outputs = forecaster_llm_model.generate(
+#             **inputs,
+#             max_new_tokens=200, # Limit the length of the generated response
+#             num_return_sequences=1,
+#             do_sample=True,
+#             top_k=50,
+#             top_p=0.95,
+#             temperature=0.7,
+#         )
+    
+#     # Decode the generated text, removing the prompt part
+#     response_text = base_tokenizer.decode(outputs[0], skip_special_tokens=True)
+#     # The response will include the prompt. We need to find the actual generated text.
+#     # This parsing might need to be more robust depending on the model's exact output format.
+#     generated_forecast = response_text.split("[/INST]")[-1].strip()
+    
+#     return generated_forecast
+
+
+# # --- Streamlit UI Layout ---
+
+# st.title("FinGPT-Powered Investment Predictor 📈")
+
+# st.markdown("""
+# This application demonstrates how financial news sentiment can be integrated with historical price data
+# to make simple investment predictions. It uses a pre-trained FinBERT-like model for sentiment analysis
+# and a Linear Regression model for price prediction.
+
+# **Disclaimer:** This is a simplified demonstration for educational purposes only.
+# It should **NOT** be used for actual investment decisions. Stock market prediction is highly complex
+# and involves many more factors and sophisticated models.
+# """)
+
+# # Create tabs for better organization
+# tab1, tab2, tab3, tab4 = st.tabs(["Sentiment Analyzer", "Historical Data & Model Performance", "Predict Tomorrow's Price (Linear Regression)", "LLM Forecaster (Conceptual)"])
+
+# with tab1:
+#     st.header("Financial News Sentiment Analyzer")
+#     st.write("Enter a financial news headline or text to get its sentiment.")
+    
+#     news_input = st.text_area("News Text:", height=150, placeholder="e.g., 'Apple's stock surged after reporting record-breaking earnings.'")
+
+#     if st.button("Analyze Sentiment"):
+#         if news_input:
+#             sentiment_score, sentiment_label = get_sentiment_score_and_label(news_input)
+#             st.markdown(f"**Sentiment Score:** `{sentiment_score:.3f}` (closer to 1 is positive, -1 is negative)")
+#             st.markdown(f"**Sentiment Label:** `{sentiment_label.upper()}`")
+#         else:
+#             st.warning("Please enter some text to analyze sentiment.")
+
+# with tab2:
+#     st.header("Simulated Historical Data and Model Performance")
+#     st.write("Here's a look at the simulated historical data used and how the prediction model performed on the test set.")
+
+#     st.subheader("Sample Historical Data")
+#     st.dataframe(data.head())
+
+#     st.subheader("Prediction Model Performance")
+#     st.write(f"**Mean Squared Error (MSE):** `{mse:.2f}`")
+#     st.write(f"**R-squared (R2):** `{r2:.2f}`")
+#     st.info("A lower MSE indicates better prediction accuracy, and an R2 closer to 1 indicates that the model explains more of the variance in the target variable.")
+
+#     st.subheader("Actual vs. Predicted Prices (Test Set)")
+#     fig, ax = plt.subplots(figsize=(12, 6))
+#     ax.plot(y_test.index, y_test, label='Actual Price', marker='o', linestyle='-', markersize=4)
+#     ax.plot(y_test.index, y_pred, label='Predicted Price', marker='x', linestyle='--', markersize=4)
+#     ax.set_title('Stock Price Prediction with Sentiment (Simulated Data)')
+#     ax.set_xlabel('Date')
+#     ax.set_ylabel('Price')
+#     ax.legend()
+#     ax.grid(True)
+#     st.pyplot(fig)
+
+# with tab3:
+#     st.header("Predict Tomorrow's Price (Linear Regression)")
+#     st.write("Enter today's closing price and relevant news to get a conceptual prediction for tomorrow using a Linear Regression model.")
+
+#     last_known_price_simulated = data['Price'].iloc[-1]
+    
+#     col1, col2 = st.columns(2)
+#     with col1:
+#         today_closing_price = st.number_input(
+#             "Today's Closing Price:", 
+#             min_value=0.0, 
+#             value=float(f"{last_known_price_simulated:.2f}"), 
+#             step=0.1,
+#             help="Based on the last simulated price from the historical data."
+#         )
+#     with col2:
+#         today_news_headline = st.text_area(
+#             "Today's Financial News Headline:", 
+#             value="Market shows strong upward momentum, positive outlook for tech sector.", 
+#             height=100
+#         )
+
+#     if st.button("Predict Price (Linear Regression)"):
+#         if today_closing_price is not None and today_news_headline:
+#             latest_sentiment_score, latest_sentiment_label = get_sentiment_score_and_label(today_news_headline)
+#             st.write(f"**Analyzed Sentiment for Today's News:** `{latest_sentiment_label.upper()}` (Score: `{latest_sentiment_score:.3f}`)")
+
+#             # Prepare data for prediction
+#             new_data_for_prediction = pd.DataFrame({
+#                 'Previous_Day_Price': [today_closing_price],
+#                 'Previous_Day_Sentiment': [latest_sentiment_score]
+#             })
+
+#             # Make prediction
+#             tomorrow_predicted_price = model_prediction.predict(new_data_for_prediction)[0]
+            
+#             st.success(f"**Conceptual Prediction for Tomorrow's Price:** `${tomorrow_predicted_price:.2f}`")
+#             st.info("Remember, this is a conceptual prediction based on a simplified model and simulated data.")
+#         else:
+#             st.warning("Please enter both today's closing price and news headline to make a prediction.")
+
+# with tab4:
+#     st.header("LLM Forecaster (Conceptual)")
+#     st.write("This section demonstrates how a FinGPT forecaster LLM *could* generate a text-based forecast.")
+#     st.warning("Note: This model requires significant memory (GPU recommended) and its output is text-based analysis, not a precise numerical prediction like the Linear Regression model.")
+
+#     llm_ticker = st.text_input("Stock Ticker (e.g., AAPL, MSFT):", value="AAPL")
+#     llm_current_price = st.number_input("Current Price:", min_value=0.0, value=175.0, step=0.1)
+#     llm_news_summary = st.text_area("Recent News Summary:", value="Apple announced strong Q4 earnings, beating analyst expectations and showing robust iPhone sales in emerging markets.", height=100)
+#     llm_current_date = st.date_input("Current Date:", value=pd.to_datetime('2024-07-15'))
+
+#     if st.button("Get LLM Forecast"):
+#         if llm_ticker and llm_current_price is not None and llm_news_summary and llm_current_date:
+#             with st.spinner("Generating LLM forecast... This may take a moment."):
+#                 forecast_text = get_llm_forecast(llm_ticker, llm_current_date, llm_news_summary, llm_current_price)
+#                 st.subheader("LLM's Forecast and Analysis:")
+#                 st.write(forecast_text)
+#         else:
+#             st.warning("Please fill in all fields to get an LLM forecast.")
+
+
 import streamlit as st
 import pandas as pd
 import numpy as np
 import torch
+# from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForCausalLM
+# from peft import PeftModel
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForCausalLM
-from peft import PeftModel
+from peft import PeftModel, LoraConfig, get_peft_model # Ensure PeftModel is imported
 from sklearn.linear_model import LinearRegression
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import mean_squared_error, r2_score
@@ -16,23 +403,34 @@ st.set_page_config(layout="wide", page_title="FinGPT Investment Predictor")
 
 # Use st.cache_resource to load heavy models only once
 @st.cache_resource
-def load_sentiment_model(sentiment_model_name="FinGPT/fingpt-sentiment_llama2-13b_lora", 
-                         base_tokenizer_name="meta-llama/Llama-2-13b-chat-hf"): # Added base_tokenizer_name
+def load_sentiment_model(sentiment_lora_name="FinGPT/fingpt-sentiment_llama2-13b_lora",
+                         base_model_name="meta-llama/Llama-2-13b-chat-hf"):
     """
-    Loads the pre-trained sentiment analysis model and tokenizer.
+    Loads the pre-trained sentiment analysis model (base + LoRA) and tokenizer.
     Uses st.cache_resource to prevent reloading on every Streamlit rerun.
     """
-    st.write(f"Loading sentiment tokenizer from base model: {base_tokenizer_name}...")
-    tokenizer = AutoTokenizer.from_pretrained(base_tokenizer_name) # Load tokenizer from base Llama model
+    st.write(f"Loading base tokenizer from: {base_model_name}...")
+    tokenizer = AutoTokenizer.from_pretrained(base_model_name)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
 
-    st.write(f"Loading sentiment model: {sentiment_model_name}...")
-    # Load the sentiment model (which is the LoRA adapter)
-    model = AutoModelForSequenceClassification.from_pretrained(sentiment_model_name)
-    model.eval() # Set model to evaluation mode
+    st.write(f"Loading base model for sentiment: {base_model_name}...")
+    # Load the base Llama 2 model as AutoModelForCausalLM
+    base_model = AutoModelForCausalLM.from_pretrained(
+        base_model_name,
+        torch_dtype=torch.float16, # Or bfloat16 if your GPU supports it
+        device_map="auto"
+    )
+
+    st.write(f"Loading sentiment LoRA adapter: {sentiment_lora_name}...")
+    # Load the LoRA adapter on top of the base model
+    sentiment_model = PeftModel.from_pretrained(base_model, sentiment_lora_name)
+    sentiment_model.eval()
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model.to(device)
+    sentiment_model.to(device)
     st.write(f"Sentiment model loaded. Using device: {device}")
-    return tokenizer, model, device
+
+    return tokenizer, sentiment_model, device
 
 tokenizer, sentiment_model, device = load_sentiment_model()