如何使用Keras / Theano for Regression配置一个非常简单的LSTM

3 回答

• 1

  在模型定义中，您在LSTM图层之前放置了一个Dense图层 . 您需要在Dense图层上使用TimeDistributed图层 .

  试着改变

  model = Sequential([
      Dense(8, input_dim=nb_features),
      Activation('softmax'),
      LSTM(4, dropout_W=0.2, dropout_U=0.2),
      Dense(1),
      Activation('sigmoid')
  ])
  

  至

  model = Sequential([
      TimeDistributed(Dense(8, input_dim=nb_features, Activation='softmax')),
      LSTM(4, dropout_W=0.2, dropout_U=0.2),
      Dense(1),
      Activation('sigmoid')
  ])
  

  回复于 2024-05-02T14:24:43+08:00
• 0

  在将数据提供给LSTM之前，您仍然缺少一个预处理步骤 . 您必须决定在计算当天的AdjClose时要包含的先前数据样本（前几天） . 请参阅我的回答here如何做到这一点 . 那么您的数据应该是三维形状（nb_samples，nb_included_previous_days，features） .

  然后，您可以使用一个输出将3D提供给标准LSTM图层 . 您可以将此值与y_train进行比较，并尝试将错误最小化 . 请记住选择适合回归的损失函数，例如：均方误差 .

  回复于 2024-05-02T14:24:43+08:00
• 2

  不确定这是否仍然相关，但有一个很好的例子，说明如何使用LSTM网络预测Jason Brownlees博士的时间序列博客here

  我准备了三个具有不同幅度的噪声相移正弦波的例子 . 不是市场数据，但我认为，你假设一只股票会说另一种股票 .

  import numpy
  import matplotlib.pyplot as plt
  import pandas
  import math
  from keras.models import Sequential
  from keras.layers import Dense
  from keras.layers import LSTM
  from keras.layers import Reshape
  from sklearn.preprocessing import MinMaxScaler
  from sklearn.metrics import mean_squared_error
  # generate sine wavepip
  def make_sine_with_noise(_start, _stop, _step, _phase_shift, gain):
      x = numpy.arange(_start, _stop, step = _step)
      noise = numpy.random.uniform(-0.1, 0.1, size = len(x))
      y = gain*0.5*numpy.sin(x+_phase_shift)
      y = numpy.add(noise, y)
      return x, y
  # convert an array of values into a dataset matrix
  def create_dataset(dataset, look_back=1, look_ahead=1):
      dataX, dataY = [], []
      for i in range(len(dataset) - look_back - look_ahead - 1):
          a = dataset[i:(i + look_back), :]
          dataX.append(a)
          b = dataset[(i + look_back):(i + look_back + look_ahead), :]
          dataY.append(b)
      return numpy.array(dataX), numpy.array(dataY)
  # fix random seed for reproducibility
  numpy.random.seed(7)
  # generate sine wave
  x1, y1 = make_sine_with_noise(0, 200, 1/24, 0, 1)
  x2, y2 = make_sine_with_noise(0, 200, 1/24, math.pi/4, 3)
  x3, y3 = make_sine_with_noise(0, 200, 1/24, math.pi/2, 20)
  # plt.plot(x1, y1)
  # plt.plot(x2, y2)
  # plt.plot(x3, y3)
  # plt.show()
  #transform to pandas dataframe
  dataframe = pandas.DataFrame({'y1': y1, 'y2': y2, 'x3': y3})
  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 = 10
  look_ahead = 5
  trainX, trainY = create_dataset(train, look_back, look_ahead)
  testX, testY = create_dataset(test, look_back, look_ahead)
  print(trainX.shape)
  print(trainY.shape)
  # reshape input to be [samples, time steps, features]
  trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], trainX.shape[2]))
  testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], testX.shape[2]))
  # create and fit the LSTM network
  model = Sequential()
  model.add(LSTM(look_ahead, input_shape=(trainX.shape[1], trainX.shape[2]), return_sequences=True))
  model.add(LSTM(look_ahead, input_shape=(look_ahead, trainX.shape[2])))
  model.add(Dense(trainY.shape[1]*trainY.shape[2]))
  model.add(Reshape((trainY.shape[1], trainY.shape[2])))
  model.compile(loss='mean_squared_error', optimizer='adam')
  model.fit(trainX, trainY, epochs=1, batch_size=1, verbose=1)
  # make prediction
  trainPredict = model.predict(trainX)
  testPredict = model.predict(testX)
  
  #save model
  model.save('my_sin_prediction_model.h5')
  
  trainPredictPlottable = trainPredict[::look_ahead]
  trainPredictPlottable = [item for sublist in trainPredictPlottable for item in sublist]
  trainPredictPlottable = scaler.inverse_transform(numpy.array(trainPredictPlottable))
  # create single testPredict array concatenating every 'look_ahed' prediction array
  testPredictPlottable = testPredict[::look_ahead]
  testPredictPlottable = [item for sublist in testPredictPlottable for item in sublist]
  testPredictPlottable = scaler.inverse_transform(numpy.array(testPredictPlottable))
  # testPredictPlottable = testPredictPlottable[:-look_ahead]
  # shift train predictions for plotting
  trainPredictPlot = numpy.empty_like(dataset)
  trainPredictPlot[:, :] = numpy.nan
  trainPredictPlot[look_back:len(trainPredictPlottable)+look_back, :] = trainPredictPlottable
  # shift test predictions for plotting
  testPredictPlot = numpy.empty_like(dataset)
  testPredictPlot[:, :] = numpy.nan
  testPredictPlot[len(dataset)-len(testPredictPlottable):len(dataset), :] = testPredictPlottable
  # plot baseline and predictions
  dataset = scaler.inverse_transform(dataset)
  plt.plot(dataset, color='k')
  plt.plot(trainPredictPlot)
  plt.plot(testPredictPlot)
  plt.show()
  

  回复于 2024-05-02T14:24:43+08:00