Trong hướng dẫn này, chúng tôi sẽ sử dụng RNN với dữ liệu Time Series. Time Series phụ thuộc vào thời gian trước đó, có nghĩa là các giá trị trong quá khứ bao gồm thông tin quan trọng mà mạng có thể học được. Dự đoán Time Series là ước tính giá trị tương lai của bất kỳ chuỗi nào, giả sử như giá cổ phiếu, nhiệt độ, GDP, v.v.
Việc chuẩn bị dữ liệu cho RNN và Time Series hơi phức tạp. Mục tiêu là để dự đoán giá trị khác của chuỗi và chúng tôi sẽ sử dụng thông tin trong quá khứ để ước tính chi phí tại t +1. Nhãn bằng với liên tiếp đầu vào trong một khoảng thời gian.
Các bài viết liên quan:
Thứ hai, số lượng đầu vào được đặt thành 1, tức là một lần quan sát mỗi lần. Cuối cùng, bước thời gian bằng với dãy giá trị số. Nếu chúng ta đặt bước thời gian thành 10, chuỗi đầu vào sẽ trả về mười lần liên tiếp.
Nhìn vào biểu đồ bên dưới, và chúng ta phải biểu diễn dữ liệu Time Series ở bên trái và chuỗi đầu vào giả tưởng ở bên phải. Chúng tôi tạo một hàm để trả về một tập dữ liệu có giá trị ngẫu nhiên cho mỗi ngày từ tháng 1 năm 2001 đến tháng 12 năm 2016
# To plotting amazing figure %matplotlib inline import matplotlib import pandas as pd import matplotlib.pyplot as plt def create_ts(start = '2001', n = 201, freq = 'M'): ring = pd.date_range(start=start, periods=n, freq=freq) ts =pd.Series(np.random.uniform(-18, 18, size=len(rng)), ring).cumsum() return ts ts= create_ts(start = '2001', n = 192, freq = 'M') ts.tail(5)
Đầu ra:
# Left plotting diagram
plt.figure(figsize=(11,4))
plt.subplot(121)
plt.plot(ts.index, ts)
plt.plot(ts.index[90:100], ts[90:100], "b-",linewidth=3, label="A train illustration in the plotting area")
plt.title("A time series (generated)", fontsize=14)
## Right side plotted Diagram
plt.subplot(122)
plt.title("A training instance", fontsize=14)
plt.plot(ts.index[90:100], ts[90:100], "b-", markersize=8, label="instance")
plt.plot(ts.index[91:101], ts[91:101], "bo", markersize=10, label="target", markerfacecolor='red')
plt.legend(loc="upper left")
plt.xlabel("Time")
plt.show() 
Phần bên phải của biểu đồ hiển thị tất cả các chuỗi. Nó bắt đầu vào năm 2001 và kết thúc vào năm 2019. Không có ý nghĩa gì để cung cấp tất cả dữ liệu trong mạng; thay vào đó, chúng ta phải tạo một lô dữ liệu có độ dài bằng bước thời gian. Lô này sẽ là biến X. Biến Y giống như biến X nhưng thay đổi theo một chu kỳ (tức là chúng ta muốn dự báo t + 1).
Cả hai vectơ đều có cùng độ dài. Chúng ta có thể thấy điều này ở phần bên phải của biểu đồ trên. Dòng biểu thị mười giá trị của đầu vào x, trong khi nhãn chấm màu đỏ có mười giá trị, y. Lưu ý rằng, nhãn bắt đầu trước một khoảng thời gian của X và kết thúc sau một khoảng thời gian.
Xây dựng RNN để phân tích Time Series trong TensorFlow
Đã đến lúc xây dựng RNN đầu tiên của chúng tôi để dự đoán chuỗi trận. Chúng ta phải chỉ định một số siêu tham số (các tham số của mô hình, tức là số lượng tế bào thần kinh, v.v.) cho mô hình.
- Số lượng đầu vào: 1
- Bước thời gian (cửa sổ trong Time Series): 10
- Số lượng tế bào thần kinh: 120
- Số lượng đầu ra: 1
Mạng của chúng tôi sẽ học theo trình tự trong 10 ngày và chứa 120 tế bào thần kinh lặp lại. Chúng tôi cung cấp mô hình bằng một đầu vào.
Trước khi xây dựng mô hình, chúng ta cần chia tập dữ liệu thành tập đoàn tàu và tập thử nghiệm. Bộ dữ liệu đầy đủ có 222 điểm dữ liệu; Chúng tôi sẽ sử dụng 201 điểm đầu tiên để đào tạo mô hình và 21 điểm cuối cùng để kiểm tra mô hình của chúng tôi.
Sau khi chúng ta xác định một tập hợp huấn luyện và kiểm tra, chúng ta cần tạo một đối tượng chứa các lô. Trong các lô này, chúng ta có giá trị X và giá trị Y. Hãy nhớ rằng giá trị X là một khoảng thời gian. Do đó, Chúng tôi sử dụng 200 quan sát đầu tiên và bước thời gian bằng 10. Đối tượng x_batches phải có 20 lô có kích thước 10 hoặc 1. Kích thước của Y_batches giống như đối tượng X_batches, nhưng có khoảng thời gian ở trên.
Bước 1 – Tạo huấn luyện và thử nghiệm
Đầu tiên, chúng tôi chuyển đổi chuỗi thành một mảng numpy; sau đó, chúng tôi xác định các cửa sổ (số lượng mạng thời gian sẽ học từ đó), số lượng đầu vào, đầu ra và kích thước của tập hợp tàu.
series = np.array(ts) n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Sau đó, chúng tôi chia mảng thành hai tập dữ liệu.
# Split data train = series[:size_train] test = series[size_train:] print(train.shape, test.shape) (201) (21)
Bước 2 – Tạo hàm trả về X_batches và y_batches
Chúng ta có thể tạo một hàm trả về hai mảng khác nhau, một mảng cho X_batches và một cho y_batches. Làm cho nó dễ dàng hơn.
Hãy tạo một hàm để xây dựng các lô.
Lưu ý rằng, các X_batches được ghi lại theo một khoảng thời gian (chúng tôi lấy giá trị t-1). Đầu ra của hàm có ba chiều. Kích thước đầu tiên bằng số lô, thứ hai là kích thước của cửa sổ và kích thước cuối cùng là số lượng đầu vào.
Phần phức tạp của time series là để chọn các điểm dữ liệu một cách chính xác. Đối với điểm dữ liệu X, chúng tôi chọn các quan sát từ t = 1 đến t = 200, trong khi đối với điểm dữ liệu Y, chúng tôi trả lại các quan sát từ t = 2 đến 201. Khi chúng tôi có điểm dữ liệu chính xác, rất dễ dàng để định hình lại bộ truyện.
Để xây dựng đối tượng với các lô, chúng ta cần chia tập dữ liệu thành mười lô có cùng độ dài. Chúng ta có thể sử dụng phương thức định hình lại và chuyển -1 để chuỗi giống với kích thước lô. Giá trị 20 là số lượng bình luận trên mỗi lô và 1 là số lượng đầu vào.
Chúng ta cần thực hiện bước tương tự đối với nhãn.
Lưu ý rằng chúng ta cần chuyển dữ liệu theo số lần chúng ta muốn dự báo. Ví dụ: nếu chúng ta muốn dự đoán một lần, thì chúng ta chuyển chuỗi số đi 1. Nếu chúng ta muốn dự báo hai ngày, thì hãy dịch chuyển dữ liệu đi 2 điểm.
x_data = train[:size_train-1]: Select the training instance.
X_batches = x_data.reshape(-1, Windows, input): creating the right shape for the batch.
def create_batches(df, Windows, input, output):
## Create X
x_data = train[:size_train-1] # Select the data
X_batches = x_data.reshape(-1, windows, input) # Reshaping the data in this line of code
## Create y
y_data = train[n_output:size_train]
y_batches = y_data.reshape(-1, Windows, output)
return X_batches, y_batches #return the function Bây giờ hàm đã được xác định, chúng ta gọi nó để tạo các lô.
Windows = n_
Windows, # Creating windows
input = n_input,
output = n_output) Chúng tôi có thể in hình dạng để đảm bảo kích thước là chính xác.
print(X_batches.shape, y_batches.shape) (10, 20, 1) (10, 20, 1)
Chúng ta cần tạo bộ thử nghiệm chỉ với một lô dữ liệu và 20 quan sát.
Lưu ý rằng dự báo của chúng tôi ngày này qua ngày khác, điều đó có nghĩa là giá trị dự đoán thứ hai sẽ dựa trên giá trị thực tế của ngày đầu tiên (t + 1) của tập dữ liệu thử nghiệm. Giá trị thực sẽ được biết.
Nếu bạn muốn dự báo t + 2, chúng ta cần sử dụng giá trị dự đoán t + 1; nếu bạn định dự đoán t + 3, chúng ta cần sử dụng giá trị kỳ vọng t + 1 và t + 2. Rất khó để dự đoán chính xác ngày “t + n”.
X_test, y_test = create_batches(df = test, windows = 20,input = 1, output = 1) print(X_test.shape, y_test.shape) (10, 20, 1) (10, 20, 1)
Kích thước lô của chúng tôi đã sẵn sàng, chúng tôi có thể xây dựng kiến trúc RNN. Hãy nhớ rằng, chúng ta có 120 tế bào thần kinh tái phát.
Bước 3 – Xây dựng mô hình
Để tạo mô hình, chúng ta cần xác định ba phần:
- Variable của tensors
- RNN
- Loss và optimization
Variable
Chúng ta cần xác định các biến X và y với một hình dạng thích hợp. Bước này là tầm thường. Các tensor có cùng thứ nguyên với các đối tượng X_batches và đối tượng y_batches.
Ví dụ: tensors X là một trình giữ chỗ có gần như ba chiều:
- Note: kích thước của lô
- n_windows: Chiều dài của cửa sổ.
- n_input: Số lượng đầu vào
Kết quả là:
tf.placeholder(tf.float32, [None, n_windows, n_input]) ## 1. Construct the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output])
RNN
Trong phần thứ hai, chúng ta cần xác định kiến trúc của mạng. Như trước đây, chúng tôi sử dụng đối tượng BasicRNNCell và dynamic_rnn từ công cụ ước lượng TensorFlow.
## 2. create the model basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
Phần tiếp theo phức tạp hơn nhưng cho phép tính toán nhanh hơn. Chúng ta cần chuyển đầu ra chạy thành một lớp dày đặc và sau đó chuyển đổi nó thành có cùng thứ nguyên như trường đầu vào.
stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Loss và optimization
Việc tối ưu hóa mô hình phụ thuộc vào nhiệm vụ mà chúng tôi đang thực hiện.
Sự khác biệt này rất quan trọng vì nó có thể thay đổi vấn đề tối ưu hóa. Bài toán tối ưu hóa cho việc sử dụng biến liên tục để giảm thiểu sai số bình phương trung bình. Để xây dựng các chỉ số này trong TF, chúng ta có thể sử dụng:
tf.reduce_sum(tf.square(outputs - y))
Mã bền giống như trước đây; chúng tôi sử dụng trình tối ưu hóa Adam để giảm tổn thất.
tf.train.AdamOptimizer(learning_rate=learning_rate) optimizer.minimize(loss)
Chúng tôi có thể đóng gói mọi thứ lại với nhau và mô hình của chúng tôi đã sẵn sàng để đào tạo.
tf.reset_default_graph() r_neuron = 120 ## 1. Constructing the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output])
## 2. creating our models basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output]) ## 3. Loss optimization of RNN learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss) init = tf.global_variables_initializer()
Chúng tôi sẽ đào tạo mô hình bằng cách sử dụng 1500 kỷ nguyên và in tổn thất sau mỗi 150 lần lặp. Sau khi mô hình được đào tạo, chúng tôi đánh giá mô hình trên tập kiểm tra và tạo một đối tượng chứa dự đoán.
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test})
"0 MSE: 502893.34
150 MSE: 13839.129
300 MSE: 3964.835
450 MSE: 2619.885
600 MSE: 2418.772
750 MSE: 2110.5923
900 MSE: 1887.9644
1050 MSE: 1747.1377
1200 MSE: 1556.3398
1350 MSE: 1384.6113" Cuối cùng, chúng ta có thể vẽ biểu đồ giá trị thực của chuỗi với giá trị dự đoán. Nếu mô hình của chúng tôi được sửa chữa, các giá trị dự đoán phải được đặt lên trên các giá trị thực tế.
Như chúng ta có thể thấy, mô hình có nhiều điểm cải tiến. Tùy thuộc vào chúng tôi để thay đổi các tham số siêu như cửa sổ, kích thước hàng loạt của số lượng nơ-ron lặp lại trong các tệp hiện tại.
plt.title("Forecast vs Actual", fontsize=14)
plt.plot(pd.Series(np.ravel(y_test)), "bo", markersize=8, label="actual", color='green')
plt.plot(pd.Series(np.ravel(y_pred)), "r.", markersize=8, label="forecast", color='red')
plt.legend(loc="lower left")
plt.xlabel("Time")
plt.show() 
Mạng nơ-ron tuần hoàn là một kiến trúc để làm việc với Time Series và phân tích văn bản. Đầu ra của trạng thái trước đó được sử dụng để bảo tồn bộ nhớ của hệ thống theo thời gian hoặc chuỗi từ.
Trong TensorFlow, chúng ta có thể sử dụng mã be; ow đã cho để đào tạo mạng nơ-ron lặp lại cho Time Series:
n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Xác định mô hình
X = tf.placeholder(tf.float32, [none, n_windows, n_input]) y = tf.placeholder(tf.float32, [none, n_windows, n_output]) basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Xây dựng chức năng tối ưu hóa
learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss)
Đào tạo người mẫu
init = tf.global_variables_initializer()
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test}) Những câu hỏi phổ biến về Time Series trong RNN
- Time series là gì trong machine learning?
Trong machine learning, time series là một chuỗi dữ liệu được thu thập theo thời gian liên tục và có thể được sử dụng để dự đoán các giá trị trong tương lai.
- RNN là gì trong machine learning?
RNN (Recurrent Neural Network) là một loại mạng neural trong machine learning được sử dụng để xử lý các chuỗi dữ liệu thời gian, trong đó thông tin được truyền tiếp và lặp lại giữa các lớp.
- Làm thế nào để xử lý time series trong RNN?
Để xử lý time series trong RNN, ta cần chuyển đổi dữ liệu thành các chuỗi thời gian và tạo các bộ dữ liệu huấn luyện và kiểm tra. Sau đó, ta sử dụng mô hình RNN để học và dự đoán các giá trị trong tương lai dựa trên dữ liệu trong quá khứ.
- Các kiến trúc RNN phổ biến nhất là gì?
Các kiến trúc RNN phổ biến nhất là Simple RNN, LSTM (Long Short-Term Memory), và GRU (Gated Recurrent Unit).
- Làm thế nào để tinh chỉnh các siêu tham số trong mô hình RNN?
Để tinh chỉnh các siêu tham số trong mô hình RNN, ta có thể sử dụng các kỹ thuật như tìm kiếm ngẫu nhiên, tìm kiếm lưới, tìm kiếm đơn hướng, hoặc tối ưu hóa thông qua thuật toán gradient descent.
- Làm thế nào để đánh giá hiệu suất của mô hình RNN?
Để đánh giá hiệu suất của mô hình RNN, ta có thể sử dụng các phương pháp đánh giá như mean squared error, mean absolute error, hay root mean squared error.
- Làm thế nào để giải quyết vấn đề overfitting trong mô hình RNN?
Để giải quyết vấn đề overfitting trong mô hình RNN, ta có thể sử dụng các kỹ thuật như tăng cường dữ liệu, giảm số lượng tham số, sử dụng dropout, hoặc early stopping.
- Các ứng dụng của RNN trong time series là gì?
RNN có thể được sử dụng trong nhiều ứng dụng khác nhau trong time series như dự đoán giá cổ phiếu, dự đoán giá vàng, dự đoán thời tiết, hay dự đoán lưu lượng truy cập trang web.
- Làm thế nào để xử lý dữ liệu bị thiếu trong time series?
Để xử lý dữ liệu bị thiếu trong time series, ta có thể sử dụng các phương pháp như lấp đầy giá trị thiếu bằng giá trị trung bình, giá trị trung vị, hoặc giá trị gần nhất. Ngoài ra, ta cũng có thể sử dụng các mô hình phức tạp hơn để dự đoán giá trị thiếu dựa trên các giá trị có sẵn.
- Các kỹ thuật feature engineering phổ biến được sử dụng trong time series là gì?
Các kỹ thuật feature engineering phổ biến được sử dụng trong time series bao gồm: chuẩn hoá dữ liệu, tạo các đặc trưng như trung bình động và độ lệch chuẩn động, tạo các biến số kỹ thuật như chuyển đổi Fourier và wavelet, và sử dụng các mô hình phức tạp hơn như PCA (Principal Component Analysis) và LDA (Linear Discriminant Analysis).
- Làm thế nào để tăng tốc độ huấn luyện mô hình RNN?
Để tăng tốc độ huấn luyện mô hình RNN, ta có thể sử dụng các kỹ thuật như tinh chỉnh siêu tham số, tăng kích thước batch, sử dụng các thuật toán tối ưu hóa hiệu quả, và sử dụng các kỹ thuật tăng tốc độ tính toán như GPU và parallel computing.
- Làm thế nào để đánh giá tính ổn định của mô hình RNN?
Để đánh giá tính ổn định của mô hình RNN, ta có thể sử dụng các phương pháp như cross-validation, kiểm tra trên dữ liệu mới, và sử dụng các chỉ số đánh giá hiệu suất như AIC (Akaike Information Criterion) và BIC (Bayesian Information Criterion).
- Các thuật toán tối ưu hóa phổ biến trong RNN là gì?
Các thuật toán tối ưu hóa phổ biến trong RNN bao gồm Gradient Descent, Stochastic Gradient Descent, Adam (Adaptive Moment Estimation), RMSProp (Root Mean Square Propagation), và Adagrad (Adaptive Gradient).
- Các mô hình RNN có thể được kết hợp với những mô hình nào khác để cải thiện hiệu suất?
Các mô hình RNN có thể được kết hợp với các mô hình khác như mạng neural tích chập (CNN), autoencoder, và transformer để cải thiện hiệu suất
