Deep Learning and Applications(202047804)
Practical 7:
Aim : Implement LSTM Model and Test it for a Given Dataset.
About LSTM Model:
Long Short-Term Memory (LSTM) is a type of Recurrent Neural Network (RNN) architecture
designed to capture long-term dependencies in sequential data. It solves the vanishing gradient
problem by introducing gates to control the flow of information.
Key Points of LSTM: - LSTMs are well-suited for time-series forecasting, text, and sequential
data. - They use input, output, and forget gates to regulate memory cell updates. - LSTMs can learn
both short-term and long-term dependencies effectively. - Applications include stock prediction,
weather forecasting, language modeling, and anomaly detection.
Python Code Implementation:
import numpy as np import matplotlib.pyplot as plt
from pandas import read_csv import math import
tensorflow as tf from tensorflow.keras.models
import Sequential from tensorflow.keras.layers
import Dense, LSTM from sklearn.preprocessing
import MinMaxScaler from sklearn.metrics import
mean_squared_error
dataframe = read_csv('/content/drive/MyDrive/DataSet/airline-passengers.csv', usecols=[1], engine='py
dataset = dataframe.values dataset = dataset.astype('float32')
# normalize the dataset scaler =
MinMaxScaler(feature_range=(0, 1)) dataset =
scaler.fit_transform(dataset)
train_size = int(len(dataset) * 0.67) test_size = len(dataset) - train_size train,
test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
def create_dataset(dataset, look_back=1):
dataX, dataY = [], [] for i in
range(len(dataset)-look_back-1):
a = dataset[i:(i+look_back), 0]
dataX.append(a) dataY.append(dataset[i +
look_back, 0]) return np.array(dataX),
np.array(dataY)
look_back = 10 trainX, trainY = create_dataset(train,
look_back) testX, testY = create_dataset(test,
look_back)
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) testX =
np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
model = Sequential()
model.add(LSTM(10, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam') model.fit(trainX,
trainY, epochs=100, batch_size=1, verbose=2)
GCET 38
Deep Learning and Applications(202047804)
trainPredict = model.predict(trainX) testPredict =
model.predict(testX)
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY]) testPredict =
scaler.inverse_transform(testPredict) testY =
scaler.inverse_transform([testY])
trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0])) print('Test
Score: %.2f RMSE' % (testScore))
trainPredictPlot = np.empty_like(dataset) trainPredictPlot[:, :] = np.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
testPredictPlot = np.empty_like(dataset) testPredictPlot[:, :] = np.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
Output :
GCET 39
Deep Learning and Applications(202047804)
GCET 40
