Tensor
Đơn vị cơ bản trong TensorFlow là các tensor. Một tensor là một vec tơ hay một ma trận – chẳng qua là một danh sách các vectơ. Các tensors có thể được khai báo với các biến hay thông qua các placeholders (Xem bài Nhập môn TensorFlow).
Biến (variable) và placeholder
Biến (variable) trong các ngôn ngữ lập trình là vùng nhớ lưu trữ dữ liệu và dữ liệu này có thể thay đổi. Trong TensorFlow, biến là các tham số của thuật toán (hay mô hình) như W (weigths) hay B (biases) và TensorFlow sẽ theo dõi sự thay đổi giá trị của các biến này để tối ưu thuật toán. Biến được tạo cùng với giá trị khởi tạo.
Cách thức chính dùng để khai báo và khởi tạo biến là sử dụng hàm Variable với đầu vào là một tensor và giá trị trả về được gán đến một biến. Ví dụ sau khai báo biến my_var và khởi tạo với một tensor:
my_var = tf.Variable(tf.zeros([2,3]))
Placeholder nắm giữ vị trí cho dữ liệu với kiểu xác định như int32, float32, v.v. để nạp vào graph với các kết quả mong đợi. Dữ liệu có thể được nạp (feed) vào placeholder nhờ tham số feed_dict trong hàm Session.run(). Để đưa placeholder vào graph, chúng ta phải thực hiện ít nhất một thao tác (phép toán hay hàm), ví dụ hàm add trong bài Nhập môn TensorFlow, trên placeholders.
Các kiểu tensor và khai báo
Chúng ta có thể khai báo một tensor như một biến. Có một số kiểu tensor cơ bản sau đây:
Tensor cố định (fixed tensors)
Tensor có thể được khai báo với giá trị cho trước gọi là các tensor cố định. Sau đây là khai báo một số tensor cố định phổ biến:
- Tensor chứa giá trị 0 dùng hàm zeros theo cú pháp: zero_tsr = tf.zeros([row_dim, col_dim]) với zero_tsr là biến chứa giá trị trả về từ hàm zeros, row_dim và col_dim theo thứ tự là số hàng và số cột.
Ví dụ:
import tensorflow as tf
zero_tsr = tf.zeros([2, 3])
with tf.Session() as sess:
zeros = sess.run(zero_tsr)
print(zeros)
Kết quả:
[[0. 0. 0.]
[0. 0. 0.]]
- Tensor chứa giá trị 1 dùng hàm ones theo cú pháp: ones_tsr = tf.ones([row_dim, col_dim]) với ones_tsr là biến chứa giá trị trả về từ hàm ones, row_dim và col_dim theo thứ tự là số hàng và số cột.
Ví dụ:
import tensorflow as tf
ones_tsr = tf.ones([2, 3])
with tf.Session() as sess:
ones= sess.run(ones_tsr)
print(ones)
Kết quả:
[[1. 1. 1.]
[1. 1. 1.]]
- Tensor chứa giá trị bất kỳ dùng hàm filled theo cú pháp: filled_tsr = tf.fill([row_dim, col_dim], constant) với filled_tsr là biến chứa giá trị trả về từ hàm fill, row_dim và col_dim theo thứ tự là số hàng và số cột, là giá trị khởi tạo với tensor .
Ví dụ:
import tensorflow as tf
filled_tsr = tf.fill([2, 3], 7)
with tf.Session() as sess:
filled_output = sess.run(filled_tsr)
print(filled_output)
Kết quả:
[[7 7 7]
[7 7 7]]
- Tensor có thể được tạo từ một giá trị hằng cho trước dùng hàm constant theo cú pháp: constant_tsr = tf.constant(const), với constant_tsr là biến chứa giá trị trả về từ hàm constant và const là một hằng cho trước có thể là số, vec tơ hay một ma trận.
Ví dụ:
import tensorflow as tf
constant_tsr = tf.constant([[1,2],[3,4],[5,6]])
with tf.Session() as sess:
constant = sess.run(constant_tsr)
print(constant)
Kết quả:
[[1 2]
[3 4]
[5 6]]
Tensor mô phỏng (Tensors of similar shape)
Chúng ta có thể khởi tạo các tensor chứa giá trị 0 hay giá trị 1 dựa trên hình ảnh (kích cỡ, chiều) của các tensor khác bằng cách dùng các hàm zeros_like hay ones_like như đoạn mã minh họa sau:
Ví dụ:
import tensorflow as tf
constant_tsr = tf.constant([[1,2],[3,4],[5,6]])
zeros_similar = tf.zeros_like(constant_tsr)
ones_similar = tf.ones_like(constant_tsr)
with tf.Session() as sess:
zeros_similar_output = sess.run(zeros_similar)
ones_similar_output = sess.run(ones_similar)
print(zeros_similar_output)
print(ones_similar_output)
Kết quả từ print(zeros_similar_output)
[[0 0]
[0 0]
[0 0]]
Kết quả từ print(ones_similar_output)
[[1 1]
[1 1]
[1 1]]
Chú ý tensor constant_str phải được khai báo trước zeros_similar và ones_similar.
Tensor dãy (Sequence tensor)
Chúng ta có thể định nghĩa tensor chứa một dãy các giá trị (theo trình tự) dùng hàm linspace() theo cú pháp:
linear_tsr = tf.linspace(start, stop, num)
Với start là giá trị bắt đầu với kiểu dữ liệu bfloat16, float32, float64; stop là giá trị kết thúc có kiểu dữ liệu bfloat16, float32, float64; num là số giá trị phát sinh với giá trị đầu tiên là start và giá trị cuối cùng là stop. Các giá trị giữa start và stop tăng (stop-start)/(num-1).
Ví dụ:
import tensorflow as tf
linspace_tsr = tf.linspace(10.0, 18.0, 3)
with tf.Session() as sess:
linspace_output = sess.run(linspace_tsr)
print(linspace_output)
Kết quả sẽ phát sinh 3 giá trị (num = 3) bắt đầu bằng start = 10.0 và kết thúc là stop = 18.0, các giá trị ở giữa tăng (18.0 – 10.0)/(3 – 1) = 4:
[10. 14. 18.]
Chúng ta cũng có thể dùng hàm range() để phát sinh tensor dãy số theo cú pháp:
range_tsr = tf.range(start, limit, delta)
Với start là giá trị bắt đầu, các giá trị kế tiếp sẽ tăng delta và nhỏ hơn limit.
Ví dụ:
import tensorflow as tf
range_tsr = tf.range(10.0, 18.0, 3)
with tf.Session() as sess:
range_output = sess.run(range_tsr)
print(range_output)
Kết quả sẽ phát sinh các giá trị bắt đầu bằng start = 10.0, các giá trị kế tiếp sẽ tăng 3 chừng nào còn nhỏ hơn limit = 18.0:
[10. 13. 16.]
Tensor ngẫu nhiên (random tensors)
Có thể khai báo một tensor với các giá trị số được phát sinh ngẫu nhiên dựa trên các hàm phân phối ngẫu nhiên như hàm phân phối đếu ngẫu nhiên random_uniform theo cú pháp:
randunif_tsr = tf.random_uniform([row_dim, col_dim], minval, maxval)
Hàm random_uniform phát sinh giá trị minval <= x < maxval.
Ví dụ:
import tensorflow as tf
randunif_tsr = tf.random_uniform([2, 3], 5, 10)
with tf.Session() as sess:
randunif_output = sess.run(randunif_tsr)
print(randunif_output)
Kết quả:
[[9.140106 5.3852124 9.501219 ]
[8.774042 8.781296 5.553758 ]]
Chúng ta cũng có thể phát sinh giá trị số ngẫu nhiên dựa trên hàm phân phối chuẩn ngẫu nhiên random_normal theo cú pháp:
randnorm_tsr = tf.random_normal([row_dim, col_dim], mean, stddev)
Với stddev là độ lệch chuẩn và mean là giá trị trung bình. Ví dụ:
import tensorflow as tf
randnorm_tsr = tf.random_normal([2, 3], 2, 1)
with tf.Session() as sess:
randnorm_output = sess.run(randnorm_tsr)
print(randnorm_output)
Kết quả:
[[1.7032695 3.0524402 2.3813055]
[1.6465333 1.3129487 3.062685 ]]
Một hàm phân phối chuẩn khác cũng được dùng phổ biến là truncated_normal giống hàm random_normal ngoại trừ rằng các giá trị lớn hơn hai độ lệch chuẩn tính từ giá trị trung bình sẽ bị cắt bỏ. Để hiểu hơn chúng ta có thể so sánh hai hình ảnh hai hàm trên:
Giá trị phát sinh từ hàm truncated_normal (nguồn stackoverflow)
Giá trị phát sinh từ hàm random_normal (nguồn stackoverflow)
Ví dụ truncated_normal:
import tensorflow as tf
truncnorm_tsr = tf.truncated_normal([2, 3], 2, 1)
with tf.Session() as sess:
truncnorm_output = sess.run(truncnorm_tsr)
print(truncnorm_output)
Kết quả:
[[1.6523125 1.8524967 1.9542828]
[1.1710547 2.0573032 2.0116537]]
Đối với mảng, chúng ta cũng có thể sắp xếp ngẫu nhiên các phần tử trong các mảng dùng hàm random_shuffle theo cú pháp:
shuffled_output = tf.random_shuffle(input_tensor)
Ví dụ:
import tensorflow as tf
constant_tsr = tf.constant([[1,2],[3,4],[5,6]])
shuffled_tsr = tf.random_shuffle(constant_tsr)
with tf.Session() as sess:
shuffled_output = sess.run(shuffled_tsr)
print(shuffled_output)
Kết quả:
[[1 2]
[5 6]
[3 4]]
Đối với các tensor ma trận, chúng ta có thể cắt ngẫu nhiên thành các tensor ma trận vuông kích thước nhỏ hơn dùng hàm random_crop theo cú pháp:
cropped_output = tf.random_crop(input_tensor, crop_size)
Ví dụ:
import tensorflow as tf
constant_tsr = tf.constant([[1,2],[3,4],[5,6]])
cropped_tsr = tf.random_crop(constant_tsr, [2,2])
with tf.Session() as sess:
cropped_output = sess.run(cropped_tsr)
print(cropped_output)
Kết quả:
[[3 4]
[5 6]]
Trong bài này chúng ta đã khám phá chi tiết về các kiểu tensor cơ bản và cách khai báo các tensor này. Mỗi kiểu tensor sẽ đi kèm với các hàm cụ thể và được minh họa qua các ví dụ và kết quả thực thi trên Anaconda. Chúng ta có thể khám pháp sâu hơn về cú pháp và cách dùng các hàm của các kiểu tensor tại tensorflow.org.
Trần Ngọc Minh Notes 
Ý kiến bài viết