initial commit

README.md

@@ -10,4 +10,21 @@ pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📈 Stock Prediction on NSE Stocks
+
+Welcome to the Stock Prediction app! This application uses the Prophet forecasting model to predict future stock prices for companies listed on the NSE (National Stock Exchange of India).
+
+## 🚀 Features
+
+- **Sentiment Analysis:** Get sentiment analysis (Positive, Negative, Neutral) based on the last available stock price and predicted price.
+- **Flexible Training Period:** Choose from different training periods (1 week, 1 month, 1 year, 10 years).
+- **Custom Forecast Horizon:** Predict stock prices for the next day, week, or month.
+- **Performance Metrics:** Evaluate the accuracy of predictions with Mean Absolute Error (MAE), Mean Squared Error (MSE), and Root Mean Squared Error (RMSE).
+
+
+## 📋 Usage
+
+1. **Select Ticker Symbol:** Choose a ticker symbol from the sidebar.
+2. **Select Training Period:** Choose the period over which the model should be trained.
+3. **Select Forecast Horizon:** Choose the period for which you want to predict stock prices.
+4. **Forecast Stock Prices:** Click the "Forecast Stock Prices" button to generate predictions.

app.py

@@ -0,0 +1,176 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from prophet import Prophet
+import yfinance as yf
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+from prophet.plot import plot_plotly, plot_components_plotly
+
+# List of ticker symbols
+ticker_symbols = ['RELIANCE', 'TCS', 'HDFCBANK', 'ICICIBANK', 'BHARTIARTL', 'SBIN', 'INFY', 'LICI', 'ITC', 'HINDUNILVR', 'LT', 'BAJFINANCE', 'HCLTECH', 'MARUTI', 'SUNPHARMA', 'ADANIENT', 'KOTAKBANK', 'TITAN', 'ONGC', 'TATAMOTORS', 'NTPC', 'AXISBANK', 'DMART', 'ADANIGREEN', 'ADANIPORTS', 'ULTRACEMCO', 'ASIANPAINT', 'COALINDIA', 'BAJAJFINSV', 'BAJAJ-AUTO', 'POWERGRID', 'NESTLEIND', 'WIPRO', 'M&M', 'IOC', 'JIOFIN', 'HAL', 'DLF', 'ADANIPOWER', 'JSWSTEEL', 'TATASTEEL', 'SIEMENS', 'IRFC', 'VBL', 'ZOMATO', 'PIDILITIND', 'GRASIM', 'SBILIFE', 'BEL', 'LTIM', 'TRENT', 'PNB', 'INDIGO', 'BANKBARODA', 'HDFCLIFE', 'ABB', 'BPCL', 'PFC', 'GODREJCP', 'TATAPOWER', 'HINDALCO', 'HINDZINC', 'TECHM', 'AMBUJACEM', 'INDUSINDBK', 'CIPLA', 'GAIL']
+
+# Function to fetch stock data from Yahoo Finance
+def fetch_stock_data(ticker_symbol, start_date, end_date):
+    ticker_symbol = ticker_symbol +".NS"
+    stock_data = yf.download(ticker_symbol, start=start_date, end=end_date)
+    df = stock_data[['Adj Close']].reset_index()
+    df = df.rename(columns={'Date': 'ds', 'Adj Close': 'y'})
+    # df.to_csv(f"{ticker_symbol}.csv")
+    return df
+
+# Function to train the Prophet model
+def train_prophet_model(df):
+    model = Prophet()
+    model.fit(df)
+    return model
+
+# Function to make the forecast
+def make_forecast(model, periods):
+    future = model.make_future_dataframe(periods=periods)
+    forecast = model.predict(future)
+    return forecast
+
+# Function to calculate performance metrics
+def calculate_performance_metrics(actual, predicted):
+    mae = mean_absolute_error(actual, predicted)
+    mse = mean_squared_error(actual, predicted)
+    rmse = np.sqrt(mse)
+    return {'MAE': mae, 'MSE': mse, 'RMSE': rmse}
+
+# Function to determine sentiment
+def determine_sentiment(actual, predicted):
+    if actual > predicted:
+        sentiment = 'Negative'
+    elif actual < predicted:
+        sentiment = 'Positive'
+    else:
+        sentiment = 'Neutral'
+    return sentiment
+
+
+# Streamlit app
+def main():
+    st.title('Stock Prediction on NSE Stocks')
+
+    # Set up the layout
+    st.sidebar.header('User Input Parameters')
+    ticker_symbol = st.sidebar.selectbox('Enter Ticker Symbol', options=ticker_symbols, index=0)
+
+    # Dropdown for training period selection
+    training_period = st.sidebar.selectbox('Select Training Period', 
+                                            options=['1 week', '1 month', '1 year', '10 years'])
+
+    # Calculate start date and end date based on training period
+    if training_period == '1 week':
+        start_date = pd.to_datetime('today') - pd.DateOffset(weeks=1)
+    elif training_period == '1 month':
+        start_date = pd.to_datetime('today') - pd.DateOffset(months=1)
+    elif training_period == '1 year':
+        start_date = pd.to_datetime('today') - pd.DateOffset(years=1)
+    elif training_period == '10 years':
+        start_date = pd.to_datetime('today') - pd.DateOffset(years=10)
+
+    end_date = pd.to_datetime('today')
+
+    # Fetching the data for the selected training period
+    df = fetch_stock_data(ticker_symbol, start_date, end_date)
+
+    # Dropdown for forecast horizon selection
+    forecast_horizon = st.sidebar.selectbox('Forecast Horizon', 
+                                            options=['Next day', 'Next week', 'Next month'],
+                                            format_func=lambda x: x.capitalize())
+    
+    # Convert the selected horizon to days
+    horizon_mapping = {'Next day': 1, 'Next week': 7, 'Next month': 30}
+    forecast_days = horizon_mapping[forecast_horizon]
+
+    if st.sidebar.button('Forecast Stock Prices'):
+        with st.spinner('Training model...'):
+            model = train_prophet_model(df)
+            forecast = make_forecast(model, forecast_days)
+
+        
+        forecast_reversed = forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].iloc[-forecast_days:].iloc[::-1]        
+
+        st.markdown("""
+            *The prediction was made using the Prophet forecasting model. The model was trained on historical stock data and used to forecast future prices based on the observed trends and patterns.*
+        """)
+        st.subheader(f'Forecast Summary for {ticker_symbol}')
+        latest_forecast = forecast_reversed.iloc[0]
+
+        # Last Stock Price details with sentiment indicator
+        actual_last_price = df["y"].iloc[-1]
+        predicted_last_price = latest_forecast['yhat']
+        sentiment = determine_sentiment(actual_last_price, predicted_last_price)
+        st.warning(f'The last available adjusted closing price for {ticker_symbol} on {end_date.strftime("%d %B %Y")} is **{actual_last_price:.2f}**.')
+
+        if sentiment == 'Positive':
+            st.success(f'Overall predication indicates positive sentiment.')
+        elif sentiment == 'Negative':
+            st.error(f'Overall predication indicates negative sentiment.')
+        else:
+            st.info(f'Overall predication indicates neutral sentiment.')        
+
+        # Prediction details
+        st.markdown(f"""
+            **Prediction for {forecast_horizon.lower()}:**
+            
+            - **Date:** {latest_forecast['ds'].strftime("%d %B %Y")}
+            - **Predicted Price:** {latest_forecast['yhat']:.2f}
+            - **Lower Bound:** {latest_forecast['yhat_lower']:.2f}
+            - **Upper Bound:** {latest_forecast['yhat_upper']:.2f}
+        """)
+
+        st.markdown(f"""
+            **Find below the prediction Data for the {forecast_horizon.lower()}:**
+            
+        """)
+        st.write(forecast_reversed)
+
+        
+        # Calculate performance metrics
+        # Function to determine if performance metrics are in a good range
+        def evaluate_performance_metrics(metrics):
+            evaluation = {}
+            evaluation['MAE'] = 'Good' if metrics['MAE'] < 0.05 * (df['y'].max() - df['y'].min()) else 'Not Good'
+            evaluation['MSE'] = 'Good' if metrics['MSE'] < 0.1 * (df['y'].max() - df['y'].min())**2 else 'Not Good'
+            evaluation['RMSE'] = 'Good' if metrics['RMSE'] < 0.1 * (df['y'].max() - df['y'].min()) else 'Not Good'
+            return evaluation
+
+        # Calculate performance metrics
+        actual = df['y']
+        predicted = forecast['yhat'][:len(df)]
+        metrics = calculate_performance_metrics(actual, predicted)
+
+        # Evaluate performance metrics
+        evaluation = evaluate_performance_metrics(metrics)
+
+        metrics = calculate_performance_metrics(actual, predicted)
+        MAE =metrics['MAE']
+        MSE = metrics['MSE']
+        RMSE = metrics['RMSE']        
+             
+
+        # Display evaluation
+        st.subheader('Performance Evaluation')
+        st.write('The metrics below provide a quantitative measure of the model’s accuracy:')
+        maecolor = "green" if evaluation["MAE"] == "Good" else "red"
+        msecolor = "green" if evaluation["MSE"] == "Good" else "red"
+        rmsecolor = "green" if evaluation["RMSE"] == "Good" else "red"
+        
+        st.markdown(f'- **Mean Absolute Error (MAE):** {MAE:.2f} - :{maecolor}[{"Good" if evaluation["MAE"] == "Good" else "Not good"}] ')
+        st.markdown("(The average absolute difference between predicted and actual values.)")
+
+        st.markdown(f'- **Mean Squared Error (MSE):** {MSE:.2f} - :{msecolor}[{"Good" if evaluation["MSE"] == "Good" else "Not good"}]  ')
+        st.markdown("(The average squared difference between predicted and actual values.)")
+
+        st.markdown(f'- **Root Mean Squared Error (RMSE):** {RMSE:.2f} - :{rmsecolor}[{"Good" if evaluation["RMSE"] == "Good" else "Not good"}] ')
+        st.markdown("(The square root of MSE, which is more interpretable in the same units as the target variable.)")
+        
+        
+        
+
+
+# Run the main function
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+
+streamlit
+pandas
+yfinance
+prophet
+numpy
+matplotlib
+plotly
+scikit-learn