Chuỗi thời gian - Mô hình LSTM

Bây giờ, chúng ta đã quen với việc lập mô hình thống kê trên chuỗi thời gian, nhưng máy học hiện đang là cơn thịnh nộ, vì vậy điều cần thiết là phải làm quen với một số mô hình máy học. Chúng ta sẽ bắt đầu với mô hình phổ biến nhất trong miền chuỗi thời gian - Mô hình Bộ nhớ Ngắn hạn Dài hạn.

LSTM là một lớp của mạng nơ-ron tuần hoàn. Vì vậy, trước khi chúng ta có thể chuyển sang LSTM, điều cần thiết là phải hiểu mạng nơ-ron và mạng nơ-ron tuần hoàn.

Mạng thần kinh

Mạng nơ-ron nhân tạo là một cấu trúc phân lớp của các nơ-ron được kết nối, lấy cảm hứng từ các mạng nơ-ron sinh học. Nó không phải là một thuật toán mà là sự kết hợp của nhiều thuật toán khác nhau cho phép chúng ta thực hiện các hoạt động phức tạp trên dữ liệu.

Mạng thần kinh tái diễn

Nó là một lớp mạng nơ-ron được thiết kế riêng để xử lý dữ liệu tạm thời. Các nơ-ron của RNN có trạng thái tế bào / bộ nhớ và đầu vào được xử lý theo trạng thái bên trong này, điều này đạt được với sự trợ giúp của các vòng lặp trong mạng nơ-ron. Có (các) mô-đun định kỳ của các lớp 'tanh' trong RNN cho phép chúng lưu giữ thông tin. Tuy nhiên, không phải trong một thời gian dài, đó là lý do tại sao chúng ta cần các mô hình LSTM.

LSTM

Đó là một loại mạng nơ-ron tái phát đặc biệt có khả năng học các phụ thuộc lâu dài trong dữ liệu. Điều này đạt được là do mô-đun định kỳ của mô hình có sự kết hợp của bốn lớp tương tác với nhau.

Hình trên mô tả bốn lớp mạng nơ-ron trong các hộp màu vàng, trỏ các toán tử khôn ngoan trong vòng tròn màu xanh lá cây, đầu vào trong vòng tròn màu vàng và trạng thái ô trong vòng tròn màu xanh lam. Một mô-đun LSTM có trạng thái ô và ba cổng cung cấp cho chúng sức mạnh để tìm hiểu, giải phóng hoặc lưu giữ thông tin một cách có chọn lọc từ mỗi đơn vị. Trạng thái tế bào trong LSTM giúp thông tin chảy qua các đơn vị mà không bị thay đổi bằng cách chỉ cho phép một số tương tác tuyến tính. Mỗi đơn vị có một đầu vào, đầu ra và một cổng quên có thể thêm hoặc bớt thông tin về trạng thái ô. Cổng quên quyết định thông tin nào từ trạng thái ô trước đó sẽ bị quên mà nó sử dụng hàm sigmoid. Cổng đầu vào điều khiển luồng thông tin đến trạng thái ô hiện tại bằng cách sử dụng phép toán nhân điểm khôn ngoan của 'sigmoid' và 'tanh' tương ứng. Cuối cùng, cổng xuất quyết định thông tin nào sẽ được chuyển sang trạng thái ẩn tiếp theo

Bây giờ chúng ta đã hiểu về hoạt động bên trong của mô hình LSTM, chúng ta hãy triển khai nó. Để hiểu việc triển khai LSTM, chúng ta sẽ bắt đầu với một ví dụ đơn giản - một đường thẳng. Hãy để chúng tôi xem, nếu LSTM có thể tìm hiểu mối quan hệ của một đường thẳng và dự đoán nó.

Đầu tiên, chúng ta hãy tạo tập dữ liệu mô tả một đường thẳng.

Trong [402]:

x = numpy.arange (1,500,1)
y = 0.4 * x + 30
plt.plot(x,y)

Ra [402]:

[<matplotlib.lines.Line2D at 0x1eab9d3ee10>]

Trong [403]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

Bây giờ, dữ liệu đã được tạo và chia thành huấn luyện và thử nghiệm. Hãy chuyển đổi dữ liệu chuỗi thời gian thành dạng dữ liệu học tập được giám sát theo giá trị của khoảng thời gian nhìn lại, về cơ bản là số độ trễ được nhìn thấy để dự đoán giá trị tại thời điểm 't'.

Vì vậy, một chuỗi thời gian như thế này -

time variable_x
t1  x1
t2  x2
 :   :
 :   :
T   xT

Khi khoảng thời gian nhìn lại là 1, được chuyển đổi thành -

x1   x2
x2   x3
 :    :
 :    :
xT-1 xT

Trong [404]:

def create_dataset(n_X, look_back):
   dataX, dataY = [], []
   for i in range(len(n_X)-look_back):
      a = n_X[i:(i+look_back), ]
      dataX.append(a)
      dataY.append(n_X[i + look_back, ])
   return numpy.array(dataX), numpy.array(dataY)

Trong [405]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)

trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

Bây giờ chúng tôi sẽ đào tạo mô hình của chúng tôi.

Các lô nhỏ dữ liệu đào tạo được hiển thị trên mạng, một lần chạy khi toàn bộ dữ liệu đào tạo được hiển thị cho mô hình theo lô và lỗi được tính toán được gọi là kỷ nguyên. Các kỷ nguyên sẽ được chạy cho đến khi thời gian lỗi giảm.

Trong [ ]:

from keras.models import Sequential
from keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(256, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(128,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic1.h5')

Trong [407]:

model.load_weights('LSTMBasic1.h5')
predict = model.predict(testx)

Bây giờ chúng ta hãy xem dự đoán của chúng tôi như thế nào.

Trong [408]:

plt.plot(testx.reshape(398,2)[:,0:1], testx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Ra [408]:

[<matplotlib.lines.Line2D at 0x1eac792f048>]

Bây giờ, chúng ta nên thử và lập mô hình sóng sin hoặc sóng cosine theo kiểu tương tự. Bạn có thể chạy đoạn mã dưới đây và thử với các thông số của mô hình để xem kết quả thay đổi như thế nào.

Trong [409]:

x = numpy.arange (1,500,1)
y = numpy.sin(x)
plt.plot(x,y)

Ra [409]:

[<matplotlib.lines.Line2D at 0x1eac7a0b3c8>]

Trong [410]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

Trong [411]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)
trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

Trong [ ]:

model = Sequential()
model.add(LSTM(512, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(256,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic2.h5')

Trong [413]:

model.load_weights('LSTMBasic2.h5')
predict = model.predict(testx)

Trong [415]:

plt.plot(trainx.reshape(398,2)[:,0:1], trainx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Hết [415]:

[<matplotlib.lines.Line2D at 0x1eac7a1f550>]

Bây giờ bạn đã sẵn sàng chuyển sang bất kỳ tập dữ liệu nào.