How do I increase accuracy with Keras using LSTM I will start with saying I am a complete beginner and doing this assignment for a class, and having some issues on how to get this to be accurate and (somewhat) show it's working! Can someone that knows way more than myself help me understand the issues and what I can do to improve what I am getting back. Thank you.
Used this as my main resource: https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/
import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error

# convert an array of values into a dataset matrix
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 numpy.array(dataX), numpy.array(dataY)

# fix random seed for reproducibility
numpy.random.seed(7)

# load the dataset
dataframe = read_csv('MonthlyData.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')

# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)

# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]

# reshape into X=t and Y=t+1
look_back = 1
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)

# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))

# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)

# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)

# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])

# calculate root mean squared error
trainScore = numpy.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = numpy.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))

# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict

# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict

# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()

This was the result:
Epoch 100/100
 - 1s - loss: 0.0180 - acc: 0.0087
Train Score: 268653367.45 RMSE
Test Score: 361613531.08 RMSE


Update:
I manually went back and normalized the data set (in Google Sheets), which I thought this part was doing (see below), and the results were much different.
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)

Result here:
Epoch 100/100
 - 1s - loss: 0.0180 - acc: 0.0087
Train Score: 0.13 RMSE
Test Score: 0.18 RMSE

 A: This is an old question, but I will answer for anyone who has the same issue and finds this question.
The issue is that you use the wrong metric. Accuracy metric is used for classification problems. It counts how many accurate predictions model made. For regression problems you need to use mean squared error or mean absolute error metrics. You can use them like this metrics=['mse'] or metrics=['mae']. It counts how close model predictions are to the labels. Less means predictions are closer to labels.
A: Add more lstm layers and increase no of epochs or batch size see the accuracy results.
You can add regularizers and/or dropout to decrease the learning capacity of your model.
may some adding more epochs also leads to overfitting the model ,due to this testing accuracy will be decreased.
be balanced  on no of epochs and batch size .
A: Judging from the history graph, there is still space for learning, try to augment the number of epochs, when you see that the model doesn't learn for a while, you could stop. Try 500 epochs, if it's too much try with patience = 10, for example. The batch size is not related to the accuracy, it's only related to speed and memory space, i.e. if you have 1000 inputs and batch size = 10, the model receives in input ALL 1000, but in batches of 10, to reduce the impact on memory... ignore the batch size if you don't have speed or memory problems.
Afterwards, you could try augmenting the nodes of the LSTM layer, not too much, it could drive to overfitting. You could even try to add another LSTM layer (be aware of how LSTM input between two LSTM layers should be; in Keras, you need return_sequences='true', for example).
