Introduction
Have you ever wondered if computers can predict stock prices? Well, they can—not perfectly, but they can learn from past data to make educated guesses about future prices. In this blog, we’ll explore how we can use a special kind of artificial intelligence (AI) called Long Short-Term Memory (LSTM) to predict the future prices of the Nifty50, India’s leading stock market index.
Don’t worry if you’re not a tech expert—we’ll explain everything in simple terms, just like teaching a friend!
How Does Stock Prediction Work?
Imagine you’re trying to predict the weather. You’d look at past weather patterns—like temperature, humidity, and rainfall—to guess if it’ll rain tomorrow. Similarly, stock prediction works by analyzing past stock prices to forecast future trends.
Here’s how we do it:
Get Historical Data – We download years of Nifty50 stock prices.
Clean the Data – Remove errors or missing values (like a teacher correcting a messy notebook).
Train the AI Model – Teach the computer to recognize patterns in stock prices.
Make Predictions – Ask the AI to predict future prices based on what it learned.
Now, let’s dive deeper into each step!
Step 1: Getting the Data
We use a library called yfinance (Yahoo Finance) to download Nifty50 stock prices from 2005 to 2025. This gives us a big table with daily prices—like a giant Excel sheet with dates and closing prices.
import yfinance as yf
start_date = '2005-05-16'
end_date = '2025-05-15'
nifty_data = yf.download('^NSEI', start=start_date, end=end_date)
Think of this as downloading a history book of stock prices.
Step 2: Cleaning the Data
Sometimes, data has missing or incorrect entries (like a torn page in a book). We fix this by:
Sorting dates correctly.
Removing or filling missing values.
print(f"Missing values in the dataset: {nifty_data.isnull().sum().sum()}")
nifty_data = nifty_data.sort_index()
This ensures our AI learns from clean, organized data.
Step 3: Scaling the Data (Making Numbers Easier to Work With)
Stock prices can be huge (like ₹20,000), but AI works better with smaller numbers (between 0 and 1). We use MinMaxScaler to shrink the numbers while keeping their relationships intact.
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(nifty_close) # nifty_close = Closing prices
This is like converting kilometers into meters—same distance, just easier to handle.
Step 4: Preparing the Data for AI Learning
AI learns from sequences. Imagine teaching a child to predict the next number in this sequence:
1, 2, 3, …? (Answer: 4)
Similarly, we give the AI sequences of 60 days’ stock prices and ask it to predict the 61st day.
def create_dataset(dataset, time_step=60):
X, y = [], []
for i in range(len(dataset) - time_step - 1):
X.append(dataset[i:(i + time_step), 0]) # 60 days of data
y.append(dataset[i + time_step, 0]) # Next day's price
return np.array(X), np.array(y)
X_train, y_train = create_dataset(train_data, time_step=60)
This way, the AI learns patterns like:
If prices rise for 10 days, will they fall soon?
Do big drops usually recover?
Step 5: Building the AI (LSTM Model)
Our AI is an LSTM (Long Short-Term Memory) network — a type of neural network great at learning sequences (like stock prices over time).
We build it like this:
First Layer (50 neurons) – Learns basic patterns.
Second Layer (50 neurons) – Learns deeper trends.
Third Layer (50 neurons) – Makes final predictions.
Dropout Layers – Prevents overfitting (like a student who memorizes answers instead of learning concepts).
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(time_step, 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(units=50))
model.add(Dropout(0.2))
model.add(Dense(units=1)) # Final prediction
We then train the model using past data, just like a student practicing with old exam papers.
Step 6: Making Predictions
After training, the AI can predict future prices. We test it on unseen data (like a surprise test) to see how well it performs.
train_predict = model.predict(X_train)
test_predict = model.predict(X_test)
We measure accuracy using:
RMSE (Root Mean Square Error) – How far predictions are from real prices.
R² Score – How well the model explains price movements (0% = random guess, 100% = perfect prediction).
train_rmse = math.sqrt(mean_squared_error(y_train_actual, train_predict))
test_r2 = r2_score(y_test_actual, test_predict)
If the AI gets ~90% accuracy, it’s doing well!
Step 7: Predicting Future Prices
Finally, we ask the AI: "What will Nifty50 prices be in the next 30 days?"
We feed it the last 60 days’ data and let it predict day by day.
last_60_days = scaled_data[-60:]
future_predictions = []
for _ in range(30):
X_future = last_60_days.reshape(1, time_step, 1)
future_pred = model.predict(X_future)
last_60_days = np.append(last_60_days[1:], future_pred)
future_predictions.append(future_pred[0, 0])
We then plot the predictions:
The red line shows what the AI thinks will happen!
- Here, the sample size is limited to get better accuracy. We need to train them with larger data.
Conclusion: Can AI Really Predict Stocks?
Yes — but with limitations.
✅ Good at:
Finding patterns in historical data.
Making short-term predictions.
❌ Not perfect at:
Predicting sudden crashes (like COVID-19).
Accounting for unexpected news (elections, wars).
Try It Yourself!
Want to run this code? Copy the full script from above and try it on Google Colab or Jupyter Notebook.
click below link and run the below code
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import yfinance as yf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Dropout
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import datetime as dt
import math
# Download market data
print("Downloading Nifty50 data...")
start_date = '2005-05-16'
end_date = '2025-05-15'
nifty_data = yf.download('^NSEI', start=start_date, end=end_date)
# Data cleaning and preprocessing
print("\nCleaning and preprocessing data...")
print(f"Missing values in the dataset: {nifty_data.isnull().sum().sum()}")
nifty_data = nifty_data.sort_index()
nifty_close = nifty_data['Close'].values.reshape(-1, 1)
# Scale the data
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(nifty_close)
# Split data into training and testing sets
train_size = int(len(scaled_data) * 0.8)
test_size = len(scaled_data) - train_size
train_data, test_data = scaled_data[0:train_size,:], scaled_data[train_size:len(scaled_data),:]
print(f"\nTraining data size: {train_size}, Testing data size: {test_size}")
def create_dataset(dataset, time_step=60):
X, y = [], []
for i in range(len(dataset) - time_step - 1):
X.append(dataset[i:(i + time_step), 0])
y.append(dataset[i + time_step, 0])
return np.array(X), np.array(y)
# Create the dataset with time steps
time_step = 60
X_train, y_train = create_dataset(train_data, time_step)
X_test, y_test = create_dataset(test_data, time_step)
# Reshape input to be [samples, time steps, features] which is required for LSTM
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
# Build LSTM model
print("\nBuilding LSTM model...")
model = Sequential()
# First LSTM layer with 50 neurons and return sequences=True to stack another LSTM layer
model.add(LSTM(units=50, return_sequences=True, input_shape=(time_step, 1)))
model.add(Dropout(0.2)) # Dropout to prevent overfitting
# Second LSTM layer with 50 neurons
model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))
# Third LSTM layer with 50 neurons
model.add(LSTM(units=50))
model.add(Dropout(0.2))
# Output layer
model.add(Dense(units=1))
# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error')
# Early stopping to prevent overfitting
early_stop = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
# Train the model
print("\nTraining the model...")
batch_size = 32
epochs = 50
history = model.fit(
X_train, y_train,
epochs=epochs,
batch_size=batch_size,
validation_split=0.1, # Use 10% of training data for validation
callbacks=[early_stop],
verbose=1
)
# Make predictions and evaluate the model
print("\nMaking predictions...")
train_predict = model.predict(X_train)
test_predict = model.predict(X_test)
# Inverse transform to get actual values
train_predict = scaler.inverse_transform(train_predict)
test_predict = scaler.inverse_transform(test_predict)
y_train_actual = scaler.inverse_transform(y_train.reshape(-1, 1))
y_test_actual = scaler.inverse_transform(y_test.reshape(-1, 1))
# Calculate performance metrics
train_rmse = math.sqrt(mean_squared_error(y_train_actual, train_predict))
test_rmse = math.sqrt(mean_squared_error(y_test_actual, test_predict))
train_mae = mean_absolute_error(y_train_actual, train_predict)
test_mae = mean_absolute_error(y_test_actual, test_predict)
train_r2 = r2_score(y_train_actual, train_predict)
test_r2 = r2_score(y_test_actual, test_predict)
# Display results
print(f"\nTraining RMSE: {train_rmse:.2f}")
print(f"Testing RMSE: {test_rmse:.2f}")
print(f"Training MAE: {train_mae:.2f}")
print(f"Testing MAE: {test_mae:.2f}")
print(f"Training R^2 Score: {train_r2:.2f}")
print(f"Testing R^2 Score: {test_r2:.2f}")
# Calculate accuracy as a percentage (simplified for this context)
def calculate_accuracy(actual, predicted, threshold=0.01):
within_threshold = np.abs(actual - predicted) <= threshold * actual
accuracy = np.mean(within_threshold) * 100
return accuracy
train_accuracy = calculate_accuracy(y_train_actual, train_predict)
test_accuracy = calculate_accuracy(y_test_actual, test_predict)
print(f"\nTraining Accuracy: {train_accuracy:.2f}%")
print(f"Testing Accuracy: {test_accuracy:.2f}%")
# Visualize the results
print("\nVisualizing results...")
train_dates = nifty_data.index[time_step+1:train_size]
test_dates = nifty_data.index[train_size+time_step:-1]
plt.figure(figsize=(14, 6))
plt.plot(train_dates, y_train_actual, label='Actual Training Data')
plt.plot(train_dates, train_predict, label='Training Predictions')
plt.plot(test_dates, y_test_actual, label='Actual Testing Data')
plt.plot(test_dates, test_predict, label='Testing Predictions')
plt.title('Nifty50 Price Prediction')
plt.xlabel('Date')
plt.ylabel('Price (INR)')
plt.legend()
plt.show()
# Future predictions
print("\nMaking future predictions...")
last_60_days = scaled_data[-60:]
future_predictions = []
for _ in range(30):
# Reshape data for prediction
X_future = last_60_days.reshape(1, time_step, 1)
# Make prediction
future_pred = model.predict(X_future)
# Append to the input data
last_60_days = np.append(last_60_days[1:], future_pred)
last_60_days = last_60_days.reshape(-1, 1)
# Store the prediction
future_predictions.append(future_pred[0, 0])
# Inverse transform to get actual values
future_predictions = np.array(future_predictions).reshape(-1, 1)
future_predictions = scaler.inverse_transform(future_predictions)
# Create future dates
last_date = nifty_data.index[-1]
future_dates = [last_date + dt.timedelta(days=i) for i in range(1, 31)]
# Visualize future predictions
plt.figure(figsize=(14, 6))
plt.plot(nifty_data.index[-100:], nifty_data['Close'].values[-100:], label='Historical Data')
plt.plot(future_dates, future_predictions, label='Future Predictions', color='red')
plt.title('Nifty50 Future Price Prediction')
plt.xlabel('Date')
plt.ylabel('Price (INR)')
plt.legend()
plt.show()
# Print model summary
print("\nModel Summary:")
model.summary()
Credits:ezcompounding
Final Thoughts
AI is a powerful tool for stock prediction, but it’s not a crystal ball. It helps investors make educated guesses, not certainties.
Would you trust AI for stock advice? Let us know in the comments! 🚀
Happy investing! 📈
Top comments (0)