5/28/2018 LSTM Wheat Price Predictions | Kaggle

We use cookies on kaggle to deliver our services, analyze web traffic, and improve your experience on the site.
By using kaggle, you agree to our use of cookies. Got it Learn more

Search kaggle  Competitions Datasets Kernels Discussion Learn Sign In

Nick Wong 
0
LSTM Wheat Price Predictions voters
L forked from LSTM Corn Predictions Ver.2 by Nick Wong (+0/–0)
last run 2 months ago · Python · 279 views
using data from Daily Wheat Price ·  Public

Code Data (1) Comments (2) Log Versions (10) Forks (1) Fork Script

Code This kernel has been released under the Apache 2.0 open source license. Download Code

1 #load and plot dataset

2 from pandas import read_csv
3 from pandas import datetime
4 from pandas import DataFrame
5 from pandas import concat
6 from pandas import Series
7 from matplotlib import pyplot
8 from sklearn.metrics import mean_squared_error
9 from sklearn.preprocessing import MinMaxScaler
10 from math import sqrt
11 from keras.models import Sequential
12 from keras.layers import Dense
13 from keras.layers import LSTM
14 from keras import optimizers
15 import numpy
16 from numpy import concatenate
17 import pandas as pd
18 import time
19
20 start = time.time()
21 #load dataset
22 def parser(x):
23 return datetime.strptime(x, '%Y-%m-%d')
24
25 #frame a sequence as a supervised learning problem
26 def timeseries_to_supervised(data, lag=1):
27 df = DataFrame(data)
28 columns = [df.shift(i) for i in range(1, lag+1)]
29 columns.append(df)
30 df = concat(columns, axis=1)
31 df.fillna(0, inplace = True)
32 return df
33
34 # convert series to supervised learning
35 def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
36 n_vars = 1 if type(data) is list else data.shape[1]
37 df = DataFrame(data)
38 cols, names = list(), list()

https://www.kaggle.com/nickwong64/lstm-wheat-price-predictions 1/5
5/28/2018 LSTM Wheat Price Predictions | Kaggle

39 # input sequence (t-n, ... t-1)

40 for i in range(n_in, 0, -1):
41 cols.append(df.shift(i))
42 names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]
43 # forecast sequence (t, t+1, ... t+n)
44 for i in range(0, n_out):
45 cols.append(df.shift(-i))
46 if i == 0:
47 names += [('var%d(t)' % (j+1)) for j in range(n_vars)]
48 else:
49 names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]
50 # put it all together
51 agg = concat(cols, axis=1)
52 agg.columns = names
53 # drop rows with NaN values
54 if dropnan:
55 agg.dropna(inplace=True)
56 return agg
57
58 #create a differenced series
59 def difference(dataset, interval=1):
60 diff = list()
61 for i in range(interval, len(dataset)):
62 value = dataset[i] - dataset[i - interval]
63 diff.append(value)
64 return numpy.array(diff)
65
66 #invert differenced value
67 def inverse_difference(history, yhat, interval=1):
68 return yhat + history[-interval]
69
70 #tranform scale for train and test data to [-1,1]
71 def scale(train, test):
72 scaler = MinMaxScaler(feature_range=(-1,1))
73 scaler = scaler.fit(train)
74 #transform train
75 train = train.reshape(train.shape[0], train.shape[1])
76 train_scaled = scaler.transform(train)
77 #transform test
78 test = test.reshape(test.shape[0], test.shape[1])
79 test_scaled = scaler.transform(test)
80 return scaler, train_scaled, test_scaled
81
82 #inverse scaling for a forecasted value
83 def invert_scale(scaler, X, value):
84 new_row = [X for x in X] + [value]
85 array = numpy.array(new_row)
86 array = array.reshape(1, len(array))
87 inverted = scaler.inverse_transform(array)
88 return inverted[0,-1]
89
90 #fit an LSTM network to training data
91 def fit_lstm(train, batch_size, nb_epoch, neurons):
92 X, Y = train[:, 0:-1], train[:, -1]
93 X = X.reshape(X.shape[0], 1, X.shape[1])
94 model = Sequential()
95 model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))
96 model.add(Dense(1))
https://www.kaggle.com/nickwong64/lstm-wheat-price-predictions 2/5
5/28/2018 LSTM Wheat Price Predictions | Kaggle

97 #set learning rate

98 #adam = optimizers.Adam(lr=0.0001)
99 adam = optimizers.Adam()
100 model.compile(loss='mean_squared_error', optimizer=adam)
101 for i in range(nb_epoch):
102 model.fit(X, Y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)
103 model.reset_states()
104 return model
105
106 #make a one-step forecast
107 def forecast_lstm(model, batch_size, X):
108 X = X.reshape(1, 1, len(X))
109 yhat = model.predict(X, batch_size = batch_size)
110 return yhat[0,0]
111
112 #load dataset
113 series = read_csv('../input/wheat_200910-201803.csv', header=0, parse_dates=[0], index_col=0, squeeze=
114 series.columns = ['open', 'high', 'low', 'close']
115 #resample to weekly Friday level, last one is excluded as not actual Friday
116 series = series.resample('W-FRI').last()
117 #remove last rows to align prediction with close price only
118 series = series.drop(series.tail(1).index)
119 #print(series.tail())
120 #transform data to be stationary
121 raw_values = series.values
122 close_values = raw_values[:,-1]
123 diff_values = difference(raw_values, 1)
124
125 #transform data to be supervised learning
126 supervised = timeseries_to_supervised(diff_values, 1)
127 supervised.columns = ['sd_open', 'sd_high', 'sd_low', 'sd_close', 'open', 'high', 'low', 'close']
128 supervised = supervised.drop(supervised.columns[[4,5,6]], axis = 1)
129 supervised_values = supervised.values
130
131 #split data into train and test sets
132 train, test = supervised_values[0:-12], supervised_values[-12:]
133
134 #tranform the scale of data
135 scaler, train_scaled, test_scaled = scale(train, test)
136
137 #print(train_scaled.shape, test_scaled.shape)
138
139 nb_epochs = 500
140 neurons = 4
141 nb_correct_predict = 0
142
143 #fit the model
144 lstm_model = fit_lstm(train_scaled, 1, nb_epochs, neurons)
145
146 #forecast the entire training dataset to build up state for forecasting
147 train_reshaped = train_scaled[:,0:-1]
148 train_reshaped = train_reshaped.reshape(train_reshaped.shape[0], 1, train_reshaped.shape[1])
149 lstm_model.predict(train_reshaped, batch_size=1)
150
151 # walk-forward validation on the test data
152 predictions = list()
153 for i in range(len(test_scaled)):
154 # make one-step forecast
https://www.kaggle.com/nickwong64/lstm-wheat-price-predictions 3/5
5/28/2018 LSTM Wheat Price Predictions | Kaggle

155 X, y = test_scaled[i, 0:-1], test_scaled[i, -1]

156 X_close = test_scaled[i,-2:-1]
157 yhat = forecast_lstm(lstm_model, 1, X)
158 # Put the predictions there and invert scale
159 test_scaled[i, -1] = yhat
160 yhat = scaler.inverse_transform(test_scaled)[i, -1]
161 # invert differencing
162 yhat = inverse_difference(close_values, yhat, len(test_scaled)+1-i)
163 # store forecast
164 predictions.append(yhat)
165 expected = close_values[len(train) + i + 1]
166 #calculate number of correct trend predictions
167 if i != 0:
168 if (expected > old_expected) and (yhat > old_yhat):
169 nb_correct_predict = nb_correct_predict+1
170 elif (expected < old_expected) and (yhat < old_yhat):
171 nb_correct_predict = nb_correct_predict+1
172 elif (expected == old_expected) and (yhat == old_yhat):
173 nb_correct_predict = nb_correct_predict+1
174 print('Date=%s, Predicted=%f, Expected=%f' % (series.index[-12+i], yhat, expected))
175 old_yhat = yhat
176 old_expected = expected
177
178 #predict the next corn price
179 last = test_scaled[-1, 0:-1]
180 yhat = forecast_lstm(lstm_model, 1, last)
181 # invert scaling
182 test_scaled[-1, -1] = yhat
183 yhat = scaler.inverse_transform(test_scaled)[-1, -1]
184 # invert differencing
185 yhat = inverse_difference(close_values, yhat, 1)
186 # print next prediction
187 print('Next predicted wheat price: %f' % yhat)
188 # print correct number of trend predictions
189 p_correct_predict = nb_correct_predict/(len(test_scaled)-1) * 100
190 print('Number of correct trend predictions: %d, percentage: %.1f' % (nb_correct_predict, p_correct_pre
191 #report performance
192 rmse = sqrt(mean_squared_error(close_values[-12:], predictions))
193 print('Number of Epochs: %d, Number of Neurons: %d' % (nb_epochs, neurons))
194 print('Test RMSE: %.3f' % rmse)
195 print('Data: Open, High, Low, Close Price')
196 end = time.time()
197 print('*********Time Used: %.5s seconds*********' %(end - start))
198 #line plot of observed vs predicted
199 pyplot.plot(close_values[-12:], label = 'Expected Value')
200 pyplot.plot(predictions, label = 'Predicted Value')
201 pyplot.legend()
202 pyplot.show()

show less

Did you find this Kernel useful? 

Show your appreciation with an upvote 0

https://www.kaggle.com/nickwong64/lstm-wheat-price-predictions 4/5
5/28/2018 LSTM Wheat Price Predictions | Kaggle

Comments (2) All Comments Sort by Hotness

Please sign in to leave a comment.

Nick Wong Kernel Author • Posted on Latest Version • 2 months ago • Options  0 

This code is based on Jason Brownlee tutorial on machine learning with little modifications. You can find his
useful tutorial below: https://machinelearningmastery.com/multivariate-time-series-forecasting-lstms-keras/

DOdoubleG • Posted on Latest Version • 2 months ago • Options  0 

这是学习前面的数据 预测最后几天的吗

© 2018 Kaggle Inc Our Team Terms Privacy Contact/Support 

https://www.kaggle.com/nickwong64/lstm-wheat-price-predictions 5/5