Rate this post

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:

  1. Variable của tensors
  2. RNN
  3. 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})  

Leave a Reply

Call now
%d bloggers like this: