Khái niệm cơ bản về TensorFlow: Tensor, Shape, Type, Sessions & Operaxoắn

Tenor là gì?

Tên của Tensorflow có nguồn gốc trực tiếp từ framework cốt lõi của nó: Tensor. Trong Tensorflow, tất cả các tính toán đều liên quan đến tensor. Tenxor là một vectơ hoặc ma trận có n chiều đại diện cho tất cả các loại dữ liệu. Tất cả các giá trị trong một tenxơ chứa kiểu dữ liệu giống hệt nhau với hình dạng đã biết (hoặc đã biết một phần). Hình dạng của dữ liệu là chiều của ma trận hoặc mảng.

Một tensor có thể được bắt nguồn từ dữ liệu đầu vào hoặc kết quả của một phép tính. Trong TensorFlow, tất cả các hoạt động được thực hiện bên trong biểu đồ. Biểu đồ là một tập hợp các phép tính diễn ra liên tiếp. Mỗi hoạt động được gọi là nút op và được kết nối với nhau.

Biểu đồ phác thảo các hoạt động và kết nối giữa các nút. Tuy nhiên, nó không hiển thị các giá trị. Cạnh của các nút là tensor, tức là một cách để điền dữ liệu vào thao tác.

Trong Machine Learning, các mô hình được cung cấp danh sách các đối tượng được gọi là vectơ đặc trưng. Một vectơ đặc trưng có thể thuộc bất kỳ loại dữ liệu nào. Vectơ đặc trưng thường sẽ là đầu vào chính để đưa vào một tenxơ. Các giá trị này sẽ chảy vào một nút op thông qua tensor và kết quả của thao tác/tính toán này sẽ tạo ra một tensor mới, do đó sẽ được sử dụng trong một thao tác mới. Tất cả các hoạt động này có thể được xem trong biểu đồ.

Biểu diễn của Tensor

Trong TensorFlow, tensor là tập hợp các vectơ đặc trưng (tức là mảng) có n chiều. Ví dụ: nếu chúng ta có ma trận 2×3 với các giá trị từ 1 đến 6, chúng ta viết:

TensorFlow biểu diễn ma trận này dưới dạng:

[[1, 2, 3], 
   [4, 5, 6]]

Nếu chúng ta tạo ma trận ba chiều có các giá trị từ 1 đến 8, chúng ta có:

TensorFlow biểu diễn ma trận này dưới dạng:

[ [[1, 2],  
       [[3, 4],  
       [[5, 6],  
       [[7,8] ]

Lưu ý: Một tensor có thể được biểu diễn bằng một đại lượng vô hướng hoặc có thể có hình dạng lớn hơn ba chiều. Nó chỉ phức tạp hơn để hình dung mức độ chiều cao hơn.

Các loại Tensor

Trong TensorFlow, tất cả các phép tính đều đi qua một hoặc nhiều tensor. Một tf.tensor là một đối tượng có ba thuộc tính:

• Một nhãn duy nhất (tên)
• Kích thước (hình dạng)
• Kiểu dữ liệu (dtype)

Mỗi thao tác bạn sẽ thực hiện với TensorFlow đều liên quan đến thao tác với tensor. Có bốn loại tensor chính mà bạn có thể tạo:

• tf.Biến
• tf.constant
• tf.placeholder
• tf.SparseTensor

Trong hướng dẫn này, bạn sẽ tìm hiểu cách tạo tf.constant và tf.Variable.

Trước khi chúng ta xem phần hướng dẫn, hãy đảm bảo bạn kích hoạt môi trường conda bằng TensorFlow. Chúng tôi đặt tên cho môi trường này là hello-tf.

Đối với người dùng MacOS:

source activate hello-tf

Trong Windows người dùng:

activate hello-tf

Sau khi thực hiện xong việc đó, bạn đã sẵn sàng nhập tensorflow

# Import tf
import tensorflow as tf

Tạo một tenxơ có chiều n

Bạn bắt đầu bằng việc tạo một tensor có một chiều, cụ thể là vô hướng.

Để tạo một tenxơ, bạn có thể sử dụng tf.constant() như trong ví dụ về hình dạng tenxơ TensorFlow bên dưới:

tf.constant(value, dtype, name = "")
arguments

- `value`: Value of n dimension to define the tensor. Optional
- `dtype`: Define the type of data:    
    - `tf.string`: String variable    
    - `tf.float32`: Float variable    
    - `tf.int16`: Integer variable
- "name": Name of the tensor. Optional. By default, `Const_1:0`

Để tạo một tenxơ có chiều 0, hãy chạy mã sau

## rank 0
# Default name
r1 = tf.constant(1, tf.int16) 
print(r1)			

Đầu ra

Tensor("Const:0", shape=(), dtype=int16)

# Named my_scalar
r2 = tf.constant(1, tf.int16, name = "my_scalar") 
print(r2)

Đầu ra

Tensor("my_scalar:0", shape=(), dtype=int16)

Mỗi tensor được hiển thị bằng tên tensor. Mỗi đối tượng tensor được xác định bằng các thuộc tính tensor như nhãn (tên) duy nhất, thứ nguyên (hình dạng) và kiểu dữ liệu TensorFlow (dtype).

Bạn có thể xác định một tensor bằng các giá trị thập phân hoặc bằng một chuỗi bằng cách thay đổi loại dữ liệu.

# Decimal
r1_decimal = tf.constant(1.12345, tf.float32)
print(r1_decimal)
# String
r1_string = tf.constant("Guru99", tf.string)
print(r1_string)

Đầu ra

Tensor("Const_1:0", shape=(), dtype=float32)
Tensor("Const_2:0", shape=(), dtype=string)

Một tenxơ có kích thước 1 có thể được tạo như sau:

## Rank 1r1_vector = tf.constant([1,3,5], tf.int16)
print(r1_vector)
r2_boolean = tf.constant([True, True, False], tf.bool)
print(r2_boolean)

Đầu ra

Tensor("Const_3:0", shape=(3,), dtype=int16)
Tensor("Const_4:0", shape=(3,), dtype=bool)

Bạn có thể nhận thấy hình dạng TensorFlow chỉ bao gồm 1 cột.

Để tạo một mảng có 2 chiều tenxơ, bạn cần đóng dấu ngoặc sau mỗi hàng. Kiểm tra ví dụ về hình dạng Tensor Keras bên dưới

## Rank 2
r2_matrix = tf.constant([ [1, 2],
                          [3, 4] ],tf.int16)
print(r2_matrix)

Đầu ra

Tensor("Const_5:0", shape=(2, 2), dtype=int16)

Ma trận có 2 hàng và 2 cột chứa các giá trị 1, 2, 3, 4.

Ma trận 3 chiều được xây dựng bằng cách thêm một cấp nữa vào trong dấu ngoặc.

## Rank 3
r3_matrix = tf.constant([ [[1, 2],
                           [3, 4], 
                           [5, 6]] ], tf.int16)
print(r3_matrix)

Đầu ra

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16)

Ma trận trông giống như hình hai.

Hình dạng của tensor

Khi bạn in tensor, TensorFlow sẽ đoán hình dạng. Tuy nhiên, bạn có thể có được hình dạng của tenxơ bằng thuộc tính hình dạng TensorFlow.

Dưới đây, bạn xây dựng một ma trận chứa các số từ 10 đến 15 và bạn kiểm tra hình dạng của m_shape

# Shape of tensor
m_shape = tf.constant([ [10, 11],
                        [12, 13],
                        [14, 15] ]                      
                     ) 
m_shape.shape

Đầu ra

TensorShape([Dimension(3), Dimension(2)])

Ma trận có 3 hàng và 2 cột.

TensorFlow có các lệnh hữu ích để tạo một vectơ hoặc ma trận chứa đầy 0 hoặc 1. Ví dụ: nếu bạn muốn tạo một tenxơ 1-D có hình dạng cụ thể là 10, chứa đầy 0, bạn có thể chạy mã bên dưới:

# Create a vector of 0
print(tf.zeros(10))

Đầu ra

Tensor("zeros:0", shape=(10,), dtype=float32)

Thuộc tính này cũng hoạt động với ma trận. Ở đây, bạn tạo một ma trận 10×10 chứa 1

# Create a vector of 1
print(tf.ones([10, 10]))

Đầu ra

Tensor("ones:0", shape=(10, 10), dtype=float32)

Bạn có thể sử dụng hình dạng của một ma trận cho trước để tạo ra một vectơ số 3. Ma trận m_shape có kích thước 2×3. Bạn có thể tạo một tenxơ với XNUMX hàng được điền bằng số XNUMX bằng mã sau:

# Create a vector of ones with the same number of rows as m_shape
print(tf.ones(m_shape.shape[0]))

Đầu ra

Tensor("ones_1:0", shape=(3,), dtype=float32)

Nếu bạn chuyển giá trị 1 vào dấu ngoặc, bạn có thể xây dựng một vectơ gồm các số bằng số cột trong ma trận m_shape.

# Create a vector of ones with the same number of column as m_shape
print(tf.ones(m_shape.shape[1]))

Đầu ra

Tensor("ones_2:0", shape=(2,), dtype=float32)

Cuối cùng, bạn có thể tạo ma trận 3×2 chỉ với một

print(tf.ones(m_shape.shape))

Đầu ra

Tensor("ones_3:0", shape=(3, 2), dtype=float32)

Loại dữ liệu

Thuộc tính thứ hai của tensor là kiểu dữ liệu. Một tensor chỉ có thể có một loại dữ liệu tại một thời điểm. Một tensor chỉ có thể có một loại dữ liệu. Bạn có thể trả về loại với thuộc tính dtype.

print(m_shape.dtype)

Đầu ra

<dtype: 'int32'>

Trong một số trường hợp, bạn muốn thay đổi loại dữ liệu. Trong TensorFlow, có thể sử dụng phương thức tf.cast.

Ví dụ

Dưới đây, một tensor float được chuyển đổi thành số nguyên bằng cách sử dụng phương thức ép kiểu.

# Change type of data
type_float = tf.constant(3.123456789, tf.float32)
type_int = tf.cast(type_float, dtype=tf.int32)
print(type_float.dtype)
print(type_int.dtype)

Đầu ra

<dtype: 'float32'>
<dtype: 'int32'>

TensorFlow tự động chọn loại dữ liệu khi đối số không được chỉ định trong quá trình tạo tensor. TensorFlow sẽ đoán loại dữ liệu nào có khả năng xảy ra nhất. Ví dụ: nếu bạn truyền một văn bản, nó sẽ đoán đó là một chuỗi và chuyển nó thành chuỗi.

Tạo toán tử

Một số toán tử TensorFlow hữu ích

Bạn đã biết cách tạo tensor bằng TensorFlow. Đã đến lúc học cách thực hiện các phép toán.

TensorFlow chứa tất cả các hoạt động cơ bản. Bạn có thể bắt đầu với một cái đơn giản. Bạn sẽ sử dụng phương pháp TensorFlow để tính bình phương của một số. Thao tác này rất đơn giản vì chỉ cần một đối số để xây dựng tensor.

Bình phương của một số được xây dựng bằng tf.sqrt(x) với x là số thực.

x = tf.constant([2.0], dtype = tf.float32)
print(tf.sqrt(x))

Đầu ra

Tensor("Sqrt:0", shape=(1,), dtype=float32)

Lưu ý: Kết quả trả về là một đối tượng tensor chứ không phải kết quả của bình phương 2. Trong ví dụ này, bạn in định nghĩa của tensor chứ không phải đánh giá thực tế của phép toán. Trong phần tiếp theo, bạn sẽ tìm hiểu cách TensorFlow hoạt động để thực hiện các thao tác.

Sau đây là danh sách các thao tác thường dùng. Ý tưởng thì giống nhau. Mỗi thao tác yêu cầu một hoặc nhiều đối số.

• tf.add(a, b)
• tf.substract(a, b)
• tf.multiply(a, b)
• tf.div(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

Ví dụ

# Add
tensor_a = tf.constant([[1,2]], dtype = tf.int32)
tensor_b = tf.constant([[3, 4]], dtype = tf.int32)

tensor_add = tf.add(tensor_a, tensor_b)print(tensor_add)

Đầu ra

Tensor("Add:0", shape=(1, 2), dtype=int32)

Giải thích mã

Tạo hai tensor:

• một tensor với 1 và 2
• một tensor với 3 và 4

Bạn cộng cả hai tensor.

Chú ý: rằng cả hai tensor cần phải có hình dạng giống nhau. Bạn có thể thực hiện phép nhân trên hai tensor.

# Multiply
tensor_multiply = tf.multiply(tensor_a, tensor_b)
print(tensor_multiply)

Đầu ra

Tensor("Mul:0", shape=(1, 2), dtype=int32)

Biến

Cho đến nay, bạn chỉ mới tạo các tensor không đổi. Nó không có ích gì nhiều. Dữ liệu luôn đến với các giá trị khác nhau, để nắm bắt được điều này, bạn có thể sử dụng lớp Biến. Nó sẽ đại diện cho một nút nơi các giá trị luôn thay đổi.

Để tạo một biến, bạn có thể sử dụng phương thức tf.get_variable()

tf.get_variable(name = "", values, dtype, initializer)
argument
- `name = ""`: Name of the variable
- `values`: Dimension of the tensor
- `dtype`: Type of data. Optional
- `initializer`: How to initialize the tensor. Optional
If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.

Ví dụ: đoạn mã bên dưới tạo một biến hai chiều với hai giá trị ngẫu nhiên. Theo mặc định, TensorFlow trả về một giá trị ngẫu nhiên. Bạn đặt tên cho biến var

# Create a Variable
## Create 2 Randomized values
var = tf.get_variable("var", [1, 2])
print(var.shape)

Đầu ra

(1, 2)

Trong ví dụ thứ hai, bạn tạo một biến có một hàng và hai cột. Bạn cần sử dụng [1,2] để tạo thứ nguyên của biến

Các giá trị ban đầu của tensor này bằng 0. Ví dụ: khi huấn luyện một mô hình, bạn cần có các giá trị ban đầu để tính trọng số của các đặc trưng. Dưới đây, bạn đặt các giá trị ban đầu này thành 0.

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32,  initializer=tf.zeros_initializer)
print(var_init_1.shape)

Đầu ra

(1, 2)

Bạn có thể truyền các giá trị của tensor không đổi vào một biến. Bạn tạo một tensor không đổi bằng phương thức tf.constant(). Bạn sử dụng tensor này để khởi tạo biến.

Các giá trị đầu tiên của biến là 10, 20, 30 và 40. Tensor mới sẽ có dạng 2×2.

# Create a 2x2 matrixtensor_const = tf.constant([[10, 20],
[30, 40]])
# Initialize the first value of the tensor equals to tensor_const
var_init_2 = tf.get_variable("var_init_2", dtype=tf.int32,  initializer=tensor_const)
print(var_init_2.shape)

Đầu ra

(2, 2)

Placeholder

Một trình giữ chỗ có mục đích cung cấp tensor. Trình giữ chỗ được sử dụng để khởi tạo dữ liệu để truyền bên trong các tensor. Để cung cấp trình giữ chỗ, bạn cần sử dụng phương thức Feed_dict. Trình giữ chỗ sẽ chỉ được cung cấp trong một phiên.

Trong ví dụ tiếp theo, bạn sẽ thấy cách tạo trình giữ chỗ bằng phương thức tf.placeholder. Trong phần tiếp theo, bạn sẽ học cách cung cấp giá trị tensor thực cho một trình giữ chỗ.

Cú pháp là:

tf.placeholder(dtype,shape=None,name=None )
arguments:
- `dtype`: Type of data
- `shape`: dimension of the placeholder. Optional. By default, shape of the data
- `name`: Name of the placeholder. Optional			
data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")
print(data_placeholder_a)

Đầu ra

Tensor("data_placeholder_a:0", dtype=float32)

Phiên

TensorFlow hoạt động xung quanh 3 thành phần chính:

• Đồ thị
• máy căng
• Phiên

Các thành phần	Mô tả
Đồ thị	Biểu đồ là cơ bản trong TensorFlow. Tất cả các phép toán (ops) được thực hiện bên trong biểu đồ. Bạn có thể tưởng tượng đồ thị như một dự án trong đó mọi thao tác đều được thực hiện. Các nút đại diện cho các hoạt động này, chúng có thể hấp thụ hoặc tạo ra các tensor mới.
máy căng	Một tensor đại diện cho dữ liệu tiến triển giữa các hoạt động. Trước đây bạn đã biết cách khởi tạo một tensor. Sự khác biệt giữa hằng số và biến là giá trị ban đầu của biến sẽ thay đổi theo thời gian.
Phiên	Một phiên sẽ thực hiện thao tác từ biểu đồ. Để cung cấp cho biểu đồ các giá trị của tensor, bạn cần mở một phiên. Trong một phiên, bạn phải chạy một toán tử để tạo đầu ra.

Đồ thị và phiên là độc lập. Bạn có thể chạy một phiên và lấy các giá trị để sử dụng sau cho các tính toán tiếp theo.

Trong ví dụ dưới đây, bạn sẽ:

• Tạo hai tensor
• Tạo một hoạt động
• Mở một phiên
• In kết quả

Bước 1) Bạn tạo hai tensor x và y

## Create, run  and evaluate a session
x = tf.constant([2])
y = tf.constant([4])

Bước 2) Bạn tạo toán tử bằng cách nhân x và y

## Create operator
multiply = tf.multiply(x, y)

Bước 3) Bạn mở một phiên. Tất cả các tính toán sẽ xảy ra trong phiên. Khi bạn hoàn tất, bạn cần phải đóng phiên.

## Create a session to run the code
sess = tf.Session()result_1 = sess.run(multiply)
print(result_1)
sess.close()

Đầu ra

[8]

Giải thích mã

• tf.Session(): Mở một phiên. Tất cả các hoạt động sẽ diễn ra trong các phiên
• run(nhân): thực hiện thao tác đã tạo ở bước 2.
• print(result_1): Cuối cùng, bạn có thể in kết quả
• close(): Đóng phiên

Kết quả hiển thị 8, là phép nhân của x và y.

Một cách khác để tạo phiên là bên trong một khối. Ưu điểm là nó tự động đóng phiên.

with tf.Session() as sess:    
result_2 = multiply.eval()
print(result_2)

Đầu ra

[8]

Trong ngữ cảnh của phiên, bạn có thể sử dụng phương thức eval() để thực thi thao tác. Nó tương đương với run(). Nó làm cho mã dễ đọc hơn.

Bạn có thể tạo một phiên và xem các giá trị bên trong các tensor mà bạn đã tạo cho đến nay.

## Check the tensors created before
sess = tf.Session()
print(sess.run(r1))
print(sess.run(r2_matrix))
print(sess.run(r3_matrix))

Đầu ra

1
[[1 2] 
 [3 4]]
[[[1 2]  
  [3 4]  
  [5 6]]]

Các biến sẽ trống theo mặc định, ngay cả sau khi bạn tạo tensor. Bạn cần khởi tạo biến nếu muốn sử dụng biến đó. Đối tượng tf.global_variables_initializer() cần được gọi để khởi tạo các giá trị của một biến. Đối tượng này sẽ khởi tạo rõ ràng tất cả các biến. Điều này rất hữu ích trước khi bạn đào tạo một mô hình.

Bạn có thể kiểm tra giá trị của các biến bạn đã tạo trước đó. Lưu ý rằng bạn cần sử dụng run để đánh giá tensor

sess.run(tf.global_variables_initializer())
print(sess.run(var))
print(sess.run(var_init_1))
print(sess.run(var_init_2))

Đầu ra

[[-0.05356491  0.75867283]]
[[0 0]]
[[10 20] 
 [30 40]]

Bạn có thể sử dụng trình giữ chỗ mà bạn đã tạo trước đó và cung cấp giá trị thực cho nó. Bạn cần truyền dữ liệu vào phương thức Feed_dict.

Ví dụ bạn sẽ lấy lũy thừa của 2 trong placeholder data_placeholder_a.

import numpy as np
power_a = tf.pow(data_placeholder_a, 2)
with tf.Session() as sess:  
data = np.random.rand(1, 10)  
print(sess.run(power_a, feed_dict={data_placeholder_a: data}))  # Will succeed.

Giải thích mã

• nhập numpy dưới dạng np: Nhập thư viện gọn gàng để tạo ra dữ liệu
• tf.pow(data_placeholder_a, 2): Tạo các hoạt động
• np.random.rand(1, 10): Tạo một mảng dữ liệu ngẫu nhiên
• Feed_dict={data_placeholder_a: data}: Cung cấp dữ liệu cho phần giữ chỗ

Đầu ra

[[0.05478134 0.27213147 0.8803037  0.0398424  0.21172127 0.01444725  0.02584014 0.3763949  0.66022706 0.7565559 ]]

Đồ thị

TensorFlow phụ thuộc vào cách tiếp cận thiên tài để kết xuất hoạt động. Tất cả các tính toán được thể hiện bằng sơ đồ luồng dữ liệu. Biểu đồ luồng dữ liệu đã được phát triển để xem xét sự phụ thuộc dữ liệu giữa các hoạt động riêng lẻ. Công thức toán học hoặc thuật toán được tạo thành từ một số phép toán liên tiếp. Biểu đồ là một cách thuận tiện để trực quan hóa cách phối hợp các phép tính.

Biểu đồ cho thấy một nút và một cạnh. Nút là sự thể hiện của một thao tác, tức là đơn vị tính toán. Cạnh là tensor, nó có thể tạo ra tensor mới hoặc tiêu thụ dữ liệu đầu vào. Nó phụ thuộc vào sự phụ thuộc giữa hoạt động cá nhân.

Cấu trúc của biểu đồ kết nối các hoạt động với nhau (tức là các nút) và cách thức hoạt động của chúng là nguồn cấp dữ liệu. Lưu ý rằng biểu đồ không hiển thị đầu ra của các thao tác, nó chỉ giúp hình dung sự kết nối giữa các thao tác riêng lẻ.

Hãy xem một ví dụ.

Hãy tưởng tượng bạn muốn đánh giá hàm sau:

TensorFlow sẽ tạo một biểu đồ để thực thi hàm. Biểu đồ trông như thế này:

Bạn có thể dễ dàng nhìn thấy đường đi mà tensor sẽ đi để đến đích cuối cùng.

Chẳng hạn, bạn có thể thấy thao tác add không thể được thực hiện trước và . Biểu đồ giải thích rằng nó sẽ:

1. tính toán và:
2. cộng 1) lại với nhau
3. thêm vào 2)
4. thêm 3) vào

x = tf.get_variable("x", dtype=tf.int32,  initializer=tf.constant([5]))
z = tf.get_variable("z", dtype=tf.int32,  initializer=tf.constant([6]))
c = tf.constant([5], name =	"constant")square = tf.constant([2], name =	"square")
f = tf.multiply(x, z) + tf.pow(x, square) + z + c

Giải thích mã

• x: Khởi tạo một biến có tên x với giá trị không đổi là 5
• z: Khởi tạo một biến có tên z với giá trị không đổi là 6
• c: Khởi tạo một tensor không đổi gọi là c với giá trị không đổi là 5
• hình vuông: Khởi tạo một tensor không đổi gọi là hình vuông có giá trị không đổi là 2
• f: Xây dựng toán tử

Trong ví dụ này, chúng tôi chọn giữ giá trị của các biến cố định. Chúng tôi cũng tạo ra một tensor không đổi gọi là c, đây là tham số không đổi trong hàm f. Nó nhận một giá trị cố định là 5. Trong biểu đồ, bạn có thể thấy tham số này trong tensor được gọi là hằng số.

Chúng tôi cũng đã xây dựng một tensor không đổi cho công suất trong toán tử tf.pow(). Nó không phải là cần thiết. Chúng tôi đã làm điều đó để bạn có thể nhìn thấy tên của tenxơ trong biểu đồ. Đó là hình tròn gọi là hình vuông.

Từ biểu đồ, bạn có thể hiểu điều gì sẽ xảy ra với các tensor và làm thế nào nó có thể trả về kết quả đầu ra là 66.

Mã bên dưới đánh giá chức năng trong một phiên.

init = tf.global_variables_initializer() # prepare to initialize all variables
with tf.Session() as sess:    
	init.run() # Initialize x and y    
    function_result = f.eval()
print(function_result)

Đầu ra

[66]

Tổng kết

TensorFlow hoạt động xung quanh:

• Đồ thị: Môi trường tính toán chứa các phép toán và tensor
• Căng thẳng: Biểu thị dữ liệu (hoặc giá trị) sẽ chảy trong biểu đồ. Đó là cạnh trong đồ thị
• Sessions: Cho phép thực hiện các thao tác

Tạo một tensor không đổi

không thay đổi	vật
D0	tf.constant(1, tf.int16)
D1	tf.constant([1,3,5], tf.int16)
D2	tf.constant([ [1, 2], [3, 4] ],tf.int16)
D3	tf.constant([ [[1, 2],[3, 4], [5, 6]] ], tf.int16)

Tạo một toán tử

Tạo một toán tử	Đối tượng
a + b	tf.add(a, b)
a*b	tf.multiply(a, b)

Tạo một tensor biến đổi

Tạo một biến	vật
giá trị ngẫu nhiên	tf.get_variable(“var”, [1, 2])
giá trị khởi tạo đầu tiên	tf.get_variable(“var_init_2”, dtype=tf.int32, bộ khởi tạo=[ [1, 2], [3, 4] ])

Mở một phiên

Phiên	vật
Tạo một phiên	tf.Session ()
Chạy một phiên	tf.Session.run()
Tính giá trị tensor	biến_name.eval()
Đóng một phiên	sess.close()
Phiên theo khối	với tf.Session() là sess: