Upload 2 files

DataLoader.py

@@ -0,0 +1,119 @@
+#Class to fetch news and stock data from the web for a specific ticker and combine them into a dataframe.
+
+import pandas as pd
+import numpy as np
+import requests
+import matplotlib.pyplot as plt
+import yfinance as yf
+from datetime import datetime
+from pygooglenews import GoogleNews
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from transformers import pipeline
+class DataLoader:
+    def __init__(self, ticker, time_period_news, time_period_stock, news_decay_rate = 0):
+        self.ticker = ticker
+        self.time_period_news = time_period_news
+        self.time_period_stock = time_period_stock
+        self.news_decay_rate = news_decay_rate
+
+    def get_data(self):
+        stock_data = self.get_stock_data()
+        news_data = self.get_news_data()
+        news_sentiment = self.get_sentiment(news_data)
+        combined_data = self.combine_data(stock_data, news_sentiment)
+
+        if self.news_decay_rate != 0:
+            combined_data = self.news_decay(combined_data, self.news_decay_rate)
+
+        return combined_data
+
+
+    def get_stock_data(self):
+        data = yf.download(self.ticker, period = self.time_period_stock)
+        df = pd.DataFrame()
+        df['Open'] = data['Open']
+        df['Close'] = data['Close']
+        df['High'] = data['High']
+        df['Low'] = data['Low']
+
+        return df
+
+    def get_news_data(self):
+        googlenews = GoogleNews()
+        news_data = googlenews.search(self.ticker, when=self.time_period_news)
+        news_data = pd.DataFrame(news_data['entries'])
+        return news_data
+
+    def get_sentiment(self, news_data):
+        tokenizer = AutoTokenizer.from_pretrained("ProsusAI/finbert")
+        model = AutoModelForSequenceClassification.from_pretrained("ProsusAI/finbert")
+        classifier = pipeline('sentiment-analysis', model=model, tokenizer=tokenizer)
+
+        news_sentiment = []
+        for i in range(len(news_data)):
+            sentiment = classifier(news_data['title'][i], top_k=None)
+            postive_score = sentiment[0]['score']
+            negative_score = sentiment[1]['score']
+            neutral_score = sentiment[2]['score']
+            reformmated_time_stamp = pd.to_datetime(news_data['published'][i]).date()
+            news_sentiment.append({'Date': reformmated_time_stamp, 'positive_score': postive_score, 'negative_score': negative_score, 'neutral_score': neutral_score})
+        return pd.DataFrame(news_sentiment)
+
+    def combine_data(self, stock_data, news_sentiment):
+        news_sentiment = (
+            news_sentiment
+            .groupby('Date')
+            .mean()
+            .fillna(0)
+            .reset_index()
+            .set_index('Date')
+            .sort_index()
+        )
+
+        common_index = pd.date_range(
+            start=pd.Timestamp(min(pd.Timestamp(stock_data.index[0]), pd.Timestamp(news_sentiment.index[0]))),
+            end=pd.Timestamp(max(pd.Timestamp(stock_data.index[-1]), pd.Timestamp(news_sentiment.index[-1]))),
+            freq='D'
+        )
+        stock_data = stock_data.reindex(common_index).fillna(-1)
+
+        news_sentiment = news_sentiment.reindex(common_index).fillna(0)
+
+        #Ensure stock_data and news_sentiment have combatile indices
+        stock_data.index = pd.to_datetime(stock_data.index).normalize()
+        news_sentiment.index = pd.to_datetime(news_sentiment.index).normalize()
+
+        combined_data = pd.merge(
+            stock_data,
+            news_sentiment,
+            how='left',
+            left_index=True,
+            right_index=True
+        )
+
+        #Drop all close values that are -1
+        combined_data = combined_data[combined_data['Close'] != -1]
+        #fill all missing values with 0
+        combined_data = combined_data.fillna(0)
+
+        return combined_data
+
+    def news_decay(self, Combined_data, decay_rate):
+        #We have lots of days in the data with no news. We will fill these days with the previous days news * decay_rate
+        #This will allow us to have a more continuous news data
+        combined_data = Combined_data.copy()
+        news_columns = ['positive_score', 'negative_score', 'neutral_score']
+        #We want to start from the oldest date and work our way to the newest date
+        for i in range(1, len(combined_data)):
+            for column in news_columns:
+                if combined_data[column][i] == 0:
+                    combined_data[column][i] = combined_data[column][i-1] * decay_rate
+        return combined_data
+
+
+
+
+
+
+
+

app.py

@@ -0,0 +1,87 @@
+import gradio as gr
+from transformers import pipeline
+import yfinance as yf
+import matplotlib.pyplot as plt
+import numpy as np
+import hopsworks
+import tensorflow as tf
+from tensorflow.keras.layers import LSTM, Dense
+from tensorflow.keras.models import load_model
+from DataLoader import DataLoader
+from sklearn.preprocessing import MinMaxScaler
+
+# Function to generate a sine wave plot
+def predict(index_name="^OMX"):
+    # Load the model
+    project = hopsworks.login(api_key_value="pwWjyzF8SYsYJGQp.uZRknwAGCDPMe2covG1e4uVY4LsJXhAyKYgUNADOGY3H67mRAzoBtEJGlskTWE8h")
+    mr = project.get_model_registry()
+    model = mr.get_model("FinanceModel", version=9)
+    saved_model_dir = model.download()
+    model = load_model(saved_model_dir + "/model.keras")
+    
+    #Fetch the data used to train the model
+    time_period_news = '30d'
+    time_period_price = '3mo' #Needed to make sure we get 30 days of price data. Stock markets are closed on weekends and holidays
+    data_loader = DataLoader(index_name, time_period_news, time_period_price)
+    data = data_loader.get_data()
+
+    #Get the previous closing price
+    previous_closing_price = data['Close'].values
+    #Remove uneccessary data and scale the data
+    #The modell only takes the latest 30 days of data
+    data = data[-30:]
+
+    #Load the input and output scalers used to train the model
+    input_scaler = MinMaxScaler()
+    output_scaler = MinMaxScaler()
+
+    #Create a fake output data to fit the scaler
+    output_scaler.fit_transform(previous_closing_price.reshape(-1, 1))
+
+    #Scale the data
+    data = input_scaler.fit_transform(data)
+
+    #Format the data to be used by the model. The model expects the data to be in the shape (1, 30, 7)
+    data = data.reshape(1, 30, 7)
+    prediction = model.predict(data)
+
+    #Inverse the scaling
+    prediction = output_scaler.inverse_transform(prediction)[0]
+    print(prediction)
+
+    # predicted_value = index_close_price_list[-1] + 10
+
+    # Create the plot
+    fig, ax = plt.subplots(figsize=(8, 4))
+    ax.plot(range(len(previous_closing_price)), previous_closing_price, label="True Values", color="blue")
+    predicted_indices = np.arange(len(previous_closing_price), len(previous_closing_price) + len(prediction))
+    ax.scatter(predicted_indices, prediction, color="red", label="Predicted Value")
+    ax.axvline(len(previous_closing_price) - 1, linestyle="--", color="gray", alpha=0.6)
+    ax.set_title(f"Prediction for {index_name}")
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Index Value")
+    ax.legend()
+
+    """ fig, ax = plt.subplots(figsize=(8, 4))
+    ax.plot(previous_closing_price, label='Previous Closing Prices', linestyle='--',)
+
+    # Create an array of indices for the predicted values, right after the last index of prev_closing
+    predicted_indices = np.arange(len(previous_closing_price), len(previous_closing_price) + len(prediction))
+
+    # Plot the predicted closing prices in red, using the correct indices
+    ax.plot(predicted_indices, prediction, color='red', label='Predicted Prices',linestyle='--',) """
+    
+    return fig
+
+# Create the Gradio interface
+interface = gr.Interface(
+    fn=predict,
+    inputs=gr.Textbox(label="Financial Index Name", placeholder="Enter the name of the financial index..."),
+    outputs=gr.Plot(label="Index Prediction Plot"),
+    title="Financial Index Predictor",
+    description="Enter the name of a financial index to generate a plot showing true values for the past 30 days and the predicted value."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    interface.launch()