[Khóa học tensorflow] Bài 3 – Xây dựng mô hình linear regression

Chào tất cả các bạn, trong bài viết này Nguyễn Văn Hiếu Blog tiếp tục trình bày series về khóa học Tensorflow. Nếu bạn chưa nắm được thông tin tutorial này, bạn hãy xem bài viết giới thiệu trước tiên nhé. Bài đầu tiên sẽ mô tả chi tiết thông tin về khóa học này, các yêu cầu với người học, cài đặt môi trường và danh sách các bài học từ đầu đến cuối.

Bài học trước: Các toán tử cơ bản trong Tensorflow

Trong bài viết này, các nội dung sẽ được trình bày trong ví dụ xây dựng model linear regression với tensorflow

Toàn bộ source code của bài này các bạn có thể xem tại đây

Xây dựng mô hình Linear regression sử dụng Tensorflow

Để các bạn dễ hình dung với bài toán, ta có thể xét bài toán thực tế như sau: Bạn có một tập dữ liệu thể hiện giá của căn hộ(y) và diện tích của căn hộ đó(x). Và công việc chúng ta cần làm là làm sao ta có thể dự đoán giá của một căn hộ bất kỳ khi biết diện tích của nó.

Trong phần này, để cho đơn giản mình sẽ sử dụng một tập dữ liệu mà trong đó mỗi điểm dữ liệu gồm 2 giá trị x và y. Ta cần đi tìm hàm y = W * x + b biểu diễn mối liên hệ giữa x và y dựa trên tệp dữ liệu này. Mục tiêu là khi có x mới, chúng ta có thể tìm/dự đoán y thông qua biểu diễn này.

Đây là biểu diễn của dữ liệu huấn luyện trên không gian 2 chiều.

Nào, hãy cùng bắt tay vào bước thứ nhất: xây dựng/định nghĩa Graph.

Xây dựng Graph

Việc đầu tiên cần làm là import các thư viện cần thiết

import numpy as np # thư viện xử lý toán học
import matplotlib.pyplot as plt # thư viện dùng để vẽ đồ thị như hình phía trên
import tensorflow as tf # Tensorflow lib

Tập dữ liệu của chúng ta, bạn có thể dùng dữ liệu của riêng bạn nhé ^^.

X_train = np.asarray([3.3, 4.4, 5.5, 6.71, 6.93, 4.168, 9.779, 6.182, 7.59, 2.167,
                      7.042, 10.791, 5.313, 7.997, 5.654, 9.27, 3.1])
Y_train = np.asarray([1.7, 2.76, 2.09, 3.19, 1.694, 1.573, 3.366, 2.596, 2.53, 1.221,
                      2.827, 3.465, 1.65, 2.904, 2.42, 2.94, 1.3])
n_samples = X_train.shape[0] # Lấy số lượng mẫu huấn luyện

Ok, bây giờ chúng ta cần tạo hai cái thùng rỗng sử dụng tf.placeholder trong đó X là dữ liệu và Y là nhãn của dữ liệu. Lát nữa sẽ truyền vào X_train và Y_train tương ứng trong session.

X = tf.placeholder(tf.float32, name='X')
Y = tf.placeholder(tf.float32, name='Y')

Việc sử dụng placeholder ở đây sẽ giúp ta có thể truyền vào các mẫu dữ liệu huấn luyện khác nhau. Các bạn có thể hình dung nó giống như việc truyền tham số vào hàm, viết 1 lần và dùng được nhiều lần

Linear model của chúng ta sẽ có dạng y = w * x + b. Trong đó w và b là 2 tham số ta cần tìm. Hai tham số này sẽ thay đổi để tối ưu mất mát trong quá trình huấn luyện. Do đó, chúng ta sẽ khai báo chúng sử dụng tf.Variable và khởi tạo hai biến này bằng 0.

w = tf.get_variable('weights', initializer=tf.constant(0.0))
b = tf.get_variable('bias', initializer=tf.constant(0.0))

Khi đó, ta sẽ có model dự đoán như sau

Y_predicted = w * X + b

Để biết w và b của chúng ta đã thực sự tốt chưa? Chúng ta cần đánh giá thông qua một hàm được gọi là loss/cost function – hàm mất mát. Hàm mất mát của chúng ta sẽ được đánh giá bằng bình phương độ chênh lệch giữa kết quả thực tế và kết quả dự đoán

loss = tf.square(Y - Y_predicted, name='loss')

Mục tiêu của chúng ta là tìm w và b sao cho loss cực tiểu. Ở đây, tôi sẽ dùng GradientDescentOptimizer của TF để cực tiểu hóa hàm loss.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(loss)

Nếu bạn muốn ghi lại đồ thị của TF vừa xây dựng và xem trên tensorboard. Hãy thêm dòng lệnh này trước session

writer = tf.summary.FileWriter('./graphs', tf.get_default_graph())

# Close sau khi kết thúc session nhé
writer.close()

Thực thi trên Graph

Việc định nghĩa Graph tới đây coi như là hoàn thành, bước thứ 2 là thực thi tính toán trên graph vừa xây dựng.

Chúng ta cần khởi tạo 1 Session và khởi tạo các Variable trước khi thực thi. Chúng ta sẽ run operation optimizer đồng thời tính toán giá trị loss để theo dõi sự thay đổi. Do việc run optimizer phụ thuộc vào 2 placeholder là X và Y nên ta cần truyền vào trong quá trình run: sess.run([optimizer, loss], feed_dict={X: x, Y: y})

Ở đây, chúng ta sẽ chạy trong 100 epoch với batch_size là 1(đưa lần lượt từng mẫu huấn luyện vào)

with tf.Session() as sess:
    # Step 7: initialize the necessary variables, in this case, w and b
    sess.run(tf.global_variables_initializer())

    for i in range(100):
        total_loss = 0
        for x, y in zip(X_train, Y_train):
            # Session execute optimizer and fetch values of loss
            _, _loss = sess.run([optimizer, loss], feed_dict={X: x, Y: y})
            total_loss += _loss
        print('Epoch {0}: {1}'.format(i, total_loss / n_samples))

Chúng ta có thể thấy giá trị loss có xu hướng giảm dần sau mỗi epoch

Epoch 0: 2.248045200810713
Epoch 1: 0.3378809356106692
Epoch 2: 0.2469177870079875
Epoch 3: 0.23914439601289547
Epoch 4: 0.2375310324029723
Epoch 5: 0.23674188743461855
Epoch 6: 0.23610148448428578
Epoch 7: 0.23549330988487996
Epoch 8: 0.2348954783999087
Epoch 9: 0.2343036914612372
Epoch 10: 0.23371719465478022

Như chúng ta thấy, giá trị mất mát là tương đối nhỏ. Chứng tỏ model của chúng ta hoạt động không tồi. Sau khi train xong bạn có thể lấy giá trị w và b bằng cách sau:

w_out, b_out = sess.run([w, b])

Lưu ý: Vẫn thực thi lệnh này trong session nhé.

Lấy kết quả dự đoán của tất cả các mẫu huấn luyện

Y_pred = X_train * w_out + b_out

Bạn có thể so sánh kết quả dự đoán(bên trái) và kết quả thực tế(bên phải):

for i, j in zip(Y_pred, Y_train):
    print(i, '|', j)

1.3422471672296523 | 1.7
1.6853130280971529 | 2.76
2.028378888964653 | 2.09
2.4057513359189033 | 3.19
2.4743645080924033 | 1.694
1.6129573192596436 | 1.573
3.3629050877392292 | 3.366
2.241079722702503 | 2.596
2.6802040246129035 | 2.53
0.988889330536127 | 1.221
2.5092948502898214 | 2.827
3.6785256797373296 | 3.465
1.9700576926171778 | 1.65
2.8071383931338785 | 2.904
2.076408109486103 | 2.42
3.2041591575741766 | 2.94
1.2798715561628342 | 1.3

Biểu diễn của model sử dụng thư viện matplotlib