Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/abhishek-mallick/predict-bay-v1

This is a Streamlit app for predicting stock prices. It uses data from Yahoo Finance to show the stock's closing price, a chart of the closing price vs time, and a chart of the closing price vs time with the 100-day moving average and 200-day moving average. The user can input a valid stock ticker symbol and view the data for that stock.
https://github.com/abhishek-mallick/predict-bay-v1

ci-cd deep-learning google-cloud lstm-neural-networks machine-learning python streamlit

Last synced: 25 days ago
JSON representation

This is a Streamlit app for predicting stock prices. It uses data from Yahoo Finance to show the stock's closing price, a chart of the closing price vs time, and a chart of the closing price vs time with the 100-day moving average and 200-day moving average. The user can input a valid stock ticker symbol and view the data for that stock.

Awesome Lists containing this project

README 

        
Predictbay



google






### Problem Statement :

The stock market is volatile and unpredictable, making it difficult for investors to make informed decisions about when to buy or sell their investments. There is a need for a real-time stock market predictor that can help investors make better decisions by predicting future stock prices accurately.



### Solution Description :

We propose to build a real-time stock market predictor using machine learning. The system will collect real-time and historical stock market data from different industries and preprocess the data to remove outliers and missing values. We will then use feature engineering techniques to select the most relevant features that can affect the stock market's performance.



We will train a Deep learning model such as LSTM on the preprocessed data to predict future stock prices accurately. The model will be loaded in the Streamlit app using different modules/Libraries to generate real-time predictions. The app will display interactive charts and graphs that can show the predicted stock prices in real-time.



To ensure that the model is accurate and reliable, we will use cross-validation techniques and evaluate the model's performance using metrics such as Mean Squared Error (MSE), Root Mean Squared Error (RMSE), and Mean Absolute Error (MAE). We will also test the model on a separate test set to ensure that it can generalize well to new data.



Overall, our real-time stock market predictor will provide investors with a reliable tool that can help them make better-informed decisions about when to buy or sell their investments. By predicting future stock prices accurately, the system can help investors avoid losses and maximize their profits.



----



A list of the required modules used in the code and the command to install them using pip:



```

pip install numpy

pip install pandas

pip install yfinance

pip install streamlit

pip install pandas-datareader

pip install scikit-learn

pip install tensorflow

pip install plotly

pip install requests

pip install streamlit-lottie

pip install datetime

```












Future Prediction :



```

from keras.models import load_model

model = load_model('keras_model.h5')

last_100_days = data_testing[-100:].values

last_100_days_scaled = scaler.transform(last_100_days)

predicted_prices = []

for i in range(1):

    X_test = np.array([last_100_days_scaled])

    X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))

    predicted_price = model.predict(X_test)

    predicted_prices.append(predicted_price)

    last_100_days_scaled = np.append(last_100_days_scaled, predicted_price)

    last_100_days_scaled = np.delete(last_100_days_scaled, 0)

predicted_prices = np.array(predicted_prices)

predicted_prices = predicted_prices.reshape(predicted_prices.shape[0],predicted_prices.shape[2])

predicted_prices = scaler.inverse_transform(predicted_prices)

print('Predicted price for the next day:', predicted_prices[0][0])

```

This code block is loading a trained Keras model, using it to make predictions on the next day's stock price based on the last 100 days of historical data, and then printing out the predicted price



The `load_model` function from Keras is used to load the trained model from a saved file named `keras_model.h5`.



The next step is to get the last 100 days of historical data from the testing dataset and scale the data using the `scaler.transform` function. The scaler was previously fit to the training dataset and is used to normalize the testing data.



An empty list called `predicted_prices` is created to store the predicted prices. The for loop iterates only once and creates an array `X_test` containing the last 100 days of scaled data. The array `X_test` is then reshaped to match the input shape of the trained model, which is `(number of samples, number of timesteps, number of features)`. In this case, there is only one feature (the stock price), so the input shape is `(1, 100, 1)`.



The `model.predict` function is used to generate a prediction for the next day's stock price based on the 100 days of historical data. The predicted price is then appended to the `predicted_prices` list, and the oldest data point in `last_100_days_scaled` is replaced with the predicted price. This updated list is then used in the next iteration of the loop to generate a prediction for the following day.



Once the loop is finished, the predicted prices are inverted back to their original scale using the `scaler.inverse_transform` function. The predicted price for the next day is then printed to the console using `print('Predicted price for the next day:', predicted_prices[0][0])`.