 Xem trên TensorFlow.org |  Chạy trong Google Colab |  Xem nguồn trên GitHub |  Tải xuống sổ ghi chép |
import tensorflow as tf
import numpy as np
Tensors là mảng nhiều chiều có kiểu đồng nhất (được gọi là kiểu dtype ). Bạn có thể xem tất cả các dtypes được hỗ trợ tại tf.dtypes.DType .
Nếu bạn đã quen thuộc với NumPy , thì tensors (loại) giống như np.arrays .
Tất cả các tensor là bất biến như số và chuỗi trong Python: bạn không bao giờ có thể cập nhật nội dung của tensor, chỉ có thể tạo một tensor mới.
Khái niệm cơ bản
Hãy tạo một số tenxơ cơ bản.
Đây là tensor "vô hướng" hoặc "rank-0". Một đại lượng vô hướng chứa một giá trị duy nhất và không có "trục".
# This will be an int32 tensor by default; see "dtypes" below.
rank_0_tensor = tf.constant(4)
print(rank_0_tensor)
tf.Tensor(4, shape=(), dtype=int32)
Một tensor "vector" hoặc "rank-1" giống như một danh sách các giá trị. Một vectơ có một trục:
# Let's make this a float tensor.
rank_1_tensor = tf.constant([2.0, 3.0, 4.0])
print(rank_1_tensor)
tf.Tensor([2. 3. 4.], shape=(3,), dtype=float32)
Một tensor "ma trận" hoặc "hạng-2" có hai trục:
# If you want to be specific, you can set the dtype (see below) at creation time
rank_2_tensor = tf.constant([[1, 2],
[3, 4],
[5, 6]], dtype=tf.float16)
print(rank_2_tensor)
tf.Tensor( [[1. 2.] [3. 4.] [5. 6.]], shape=(3, 2), dtype=float16)
Vô hướng, hình dạng: [] | Một vectơ, hình dạng: [3] | Một ma trận, hình dạng: [3, 2] |
|---|---|---|
 |  |  |
Tensors có thể có nhiều trục hơn; đây là một tensor với ba trục:
# There can be an arbitrary number of
# axes (sometimes called "dimensions")
rank_3_tensor = tf.constant([
[[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]],
[[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19]],
[[20, 21, 22, 23, 24],
[25, 26, 27, 28, 29]],])
print(rank_3_tensor)
tf.Tensor( [[[ 0 1 2 3 4] [ 5 6 7 8 9]] [[10 11 12 13 14] [15 16 17 18 19]] [[20 21 22 23 24] [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)
Có nhiều cách bạn có thể hình dung một tensor có nhiều hơn hai trục.
Một tensor 3 trục, hình dạng: [3, 2, 5] | ||
|---|---|---|
 |  |  |
Bạn có thể chuyển đổi tensor thành mảng NumPy bằng cách sử dụng np.array hoặc phương thức tensor.numpy :
np.array(rank_2_tensor)
array([[1., 2.],
[3., 4.],
[5., 6.]], dtype=float16)
rank_2_tensor.numpy()
array([[1., 2.],
[3., 4.],
[5., 6.]], dtype=float16)
Tensors thường chứa float và int, nhưng có nhiều loại khác, bao gồm:
- số phức
- dây
Lớp tf.Tensor cơ sở yêu cầu các tensor là "hình chữ nhật" --- nghĩa là, dọc theo mỗi trục, mọi phần tử có cùng kích thước. Tuy nhiên, có những loại máy căng chuyên dụng có thể xử lý các hình dạng khác nhau:
- Ragged tensors (xem RaggedTensor bên dưới)
- Các căng thưa (xem SparseTensor bên dưới)
Bạn có thể làm toán cơ bản về hàng chục, bao gồm phép cộng, phép nhân theo nguyên tố và phép nhân ma trận.
a = tf.constant([[1, 2],
[3, 4]])
b = tf.constant([[1, 1],
[1, 1]]) # Could have also said `tf.ones([2,2])`
print(tf.add(a, b), "\n")
print(tf.multiply(a, b), "\n")
print(tf.matmul(a, b), "\n")
tf.Tensor( [[2 3] [4 5]], shape=(2, 2), dtype=int32) tf.Tensor( [[1 2] [3 4]], shape=(2, 2), dtype=int32) tf.Tensor( [[3 3] [7 7]], shape=(2, 2), dtype=int32)
print(a + b, "\n") # element-wise addition
print(a * b, "\n") # element-wise multiplication
print(a @ b, "\n") # matrix multiplication
tf.Tensor( [[2 3] [4 5]], shape=(2, 2), dtype=int32) tf.Tensor( [[1 2] [3 4]], shape=(2, 2), dtype=int32) tf.Tensor( [[3 3] [7 7]], shape=(2, 2), dtype=int32)
Tensors được sử dụng trong tất cả các loại hoạt động (ops).
c = tf.constant([[4.0, 5.0], [10.0, 1.0]])
# Find the largest value
print(tf.reduce_max(c))
# Find the index of the largest value
print(tf.argmax(c))
# Compute the softmax
print(tf.nn.softmax(c))
tf.Tensor(10.0, shape=(), dtype=float32) tf.Tensor([1 0], shape=(2,), dtype=int64) tf.Tensor( [[2.6894143e-01 7.3105854e-01] [9.9987662e-01 1.2339458e-04]], shape=(2, 2), dtype=float32)
Về hình dạng
Hàng căng có hình dạng. Một số từ vựng:
- Hình dạng : Chiều dài (số phần tử) của mỗi trục của tensor.
- Xếp hạng : Số trục tensor. Một vô hướng có hạng 0, một vectơ có hạng 1, một ma trận có hạng 2.
- Axis or Dimension : Một kích thước cụ thể của một tensor.
- Kích thước : Tổng số mục trong tensor, vector hình dạng sản phẩm.
Các đối tượng Tensors và tf.TensorShape có các thuộc tính thuận tiện để truy cập:
rank_4_tensor = tf.zeros([3, 2, 4, 5])
Một tensor cấp 4, hình dạng: [3, 2, 4, 5] | |
|---|---|
 |  |
print("Type of every element:", rank_4_tensor.dtype)
print("Number of axes:", rank_4_tensor.ndim)
print("Shape of tensor:", rank_4_tensor.shape)
print("Elements along axis 0 of tensor:", rank_4_tensor.shape[0])
print("Elements along the last axis of tensor:", rank_4_tensor.shape[-1])
print("Total number of elements (3*2*4*5): ", tf.size(rank_4_tensor).numpy())
Type of every element: <dtype: 'float32'> Number of axes: 4 Shape of tensor: (3, 2, 4, 5) Elements along axis 0 of tensor: 3 Elements along the last axis of tensor: 5 Total number of elements (3*2*4*5): 120
Mặc dù các trục thường được gọi bằng các chỉ số của chúng, nhưng bạn nên luôn theo dõi ý nghĩa của từng trục. Thông thường, các trục được sắp xếp từ toàn cục đến cục bộ: Trục lô đầu tiên, tiếp theo là kích thước không gian và cuối cùng là các đối tượng địa lý cho từng vị trí. Bằng cách này, các vectơ đặc trưng là các vùng liền kề của bộ nhớ.
| Thứ tự trục điển hình |
|---|
 |
Lập chỉ mục
Lập chỉ mục trục đơn
TensorFlow tuân theo các quy tắc lập chỉ mục tiêu chuẩn của Python, tương tự như lập chỉ mục một danh sách hoặc một chuỗi trong Python và các quy tắc cơ bản để lập chỉ mục NumPy.
- chỉ mục bắt đầu từ
0 - các chỉ số âm tính ngược lại từ cuối
- dấu hai chấm,
:, được sử dụng cho các lát cắt:start:stop:step
rank_1_tensor = tf.constant([0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
print(rank_1_tensor.numpy())
[ 0 1 1 2 3 5 8 13 21 34]
Lập chỉ mục với một đại lượng vô hướng loại bỏ trục:
print("First:", rank_1_tensor[0].numpy())
print("Second:", rank_1_tensor[1].numpy())
print("Last:", rank_1_tensor[-1].numpy())
First: 0 Second: 1 Last: 34
Lập chỉ mục với : lát cắt giữ trục:
print("Everything:", rank_1_tensor[:].numpy())
print("Before 4:", rank_1_tensor[:4].numpy())
print("From 4 to the end:", rank_1_tensor[4:].numpy())
print("From 2, before 7:", rank_1_tensor[2:7].numpy())
print("Every other item:", rank_1_tensor[::2].numpy())
print("Reversed:", rank_1_tensor[::-1].numpy())
Everything: [ 0 1 1 2 3 5 8 13 21 34] Before 4: [0 1 1 2] From 4 to the end: [ 3 5 8 13 21 34] From 2, before 7: [1 2 3 5 8] Every other item: [ 0 1 3 8 21] Reversed: [34 21 13 8 5 3 2 1 1 0]
Lập chỉ mục nhiều trục
Các tenxơ xếp hạng cao hơn được lập chỉ mục bằng cách chuyển nhiều chỉ số.
Các quy tắc giống hệt như trong trường hợp trục đơn áp dụng cho từng trục một cách độc lập.
print(rank_2_tensor.numpy())
[[1. 2.] [3. 4.] [5. 6.]]
Chuyển một số nguyên cho mỗi chỉ mục, kết quả là một đại lượng vô hướng.
# Pull out a single value from a 2-rank tensor
print(rank_2_tensor[1, 1].numpy())
4.0
Bạn có thể lập chỉ mục bằng cách sử dụng bất kỳ kết hợp số nguyên và lát cắt nào:
# Get row and column tensors
print("Second row:", rank_2_tensor[1, :].numpy())
print("Second column:", rank_2_tensor[:, 1].numpy())
print("Last row:", rank_2_tensor[-1, :].numpy())
print("First item in last column:", rank_2_tensor[0, -1].numpy())
print("Skip the first row:")
print(rank_2_tensor[1:, :].numpy(), "\n")
Second row: [3. 4.] Second column: [2. 4. 6.] Last row: [5. 6.] First item in last column: 2.0 Skip the first row: [[3. 4.] [5. 6.]]
Đây là một ví dụ với tensor 3 trục:
print(rank_3_tensor[:, :, 4])
tf.Tensor( [[ 4 9] [14 19] [24 29]], shape=(3, 2), dtype=int32)
| Chọn tính năng cuối cùng trên tất cả các vị trí trong mỗi ví dụ trong lô | |
|---|---|
 |  |
Đọc hướng dẫn cắt tensor để tìm hiểu cách bạn có thể áp dụng lập chỉ mục để thao tác các phần tử riêng lẻ trong tensor của bạn.
Thao tác hình dạng
Định hình lại một tensor là một tiện ích tuyệt vời.
# Shape returns a `TensorShape` object that shows the size along each axis
x = tf.constant([[1], [2], [3]])
print(x.shape)
(3, 1)
# You can convert this object into a Python list, too
print(x.shape.as_list())
[3, 1]
Bạn có thể định hình lại một tensor thành một hình dạng mới. Hoạt động tf.reshape nhanh và rẻ vì dữ liệu cơ bản không cần phải sao chép.
# You can reshape a tensor to a new shape.
# Note that you're passing in a list
reshaped = tf.reshape(x, [1, 3])
print(x.shape)
print(reshaped.shape)
(3, 1) (1, 3)
Dữ liệu duy trì bố cục của nó trong bộ nhớ và một tensor mới được tạo ra, với hình dạng được yêu cầu, trỏ đến cùng một dữ liệu. TensorFlow sử dụng thứ tự bộ nhớ "hàng-chính" kiểu C, trong đó việc tăng chỉ số ngoài cùng bên phải tương ứng với một bước duy nhất trong bộ nhớ.
print(rank_3_tensor)
tf.Tensor( [[[ 0 1 2 3 4] [ 5 6 7 8 9]] [[10 11 12 13 14] [15 16 17 18 19]] [[20 21 22 23 24] [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)
Nếu bạn làm phẳng một tensor, bạn có thể thấy thứ tự của nó trong bộ nhớ.
# A `-1` passed in the `shape` argument says "Whatever fits".
print(tf.reshape(rank_3_tensor, [-1]))
tf.Tensor( [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29], shape=(30,), dtype=int32)
Thông thường, cách sử dụng hợp lý duy nhất của tf.reshape là kết hợp hoặc tách các trục liền kề (hoặc thêm / bớt 1 s).
Đối với tensor 3x2x5 này, định dạng lại thành (3x2) x5 hoặc 3x (2x5) đều là những việc hợp lý cần làm, vì các lát cắt không trộn lẫn:
print(tf.reshape(rank_3_tensor, [3*2, 5]), "\n")
print(tf.reshape(rank_3_tensor, [3, -1]))
tf.Tensor( [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19] [20 21 22 23 24] [25 26 27 28 29]], shape=(6, 5), dtype=int32) tf.Tensor( [[ 0 1 2 3 4 5 6 7 8 9] [10 11 12 13 14 15 16 17 18 19] [20 21 22 23 24 25 26 27 28 29]], shape=(3, 10), dtype=int32)
| Một số định hình tốt. | ||
|---|---|---|
 |  |  |
Việc định hình lại sẽ "hoạt động" đối với bất kỳ hình dạng mới nào có cùng tổng số phần tử, nhưng nó sẽ không hữu ích gì nếu bạn không tôn trọng thứ tự của các trục.
Trao đổi trục trong tf.reshape không hoạt động; bạn cần tf.transpose cho điều đó.
# Bad examples: don't do this
# You can't reorder axes with reshape.
print(tf.reshape(rank_3_tensor, [2, 3, 5]), "\n")
# This is a mess
print(tf.reshape(rank_3_tensor, [5, 6]), "\n")
# This doesn't work at all
try:
tf.reshape(rank_3_tensor, [7, -1])
except Exception as e:
print(f"{type(e).__name__}: {e}")
tf.Tensor( [[[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] [[15 16 17 18 19] [20 21 22 23 24] [25 26 27 28 29]]], shape=(2, 3, 5), dtype=int32) tf.Tensor( [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23] [24 25 26 27 28 29]], shape=(5, 6), dtype=int32) InvalidArgumentError: Input to reshape is a tensor with 30 values, but the requested shape requires a multiple of 7 [Op:Reshape]
| Một số hình dạng xấu. | ||
|---|---|---|
 |  |  |
Bạn có thể gặp phải các hình dạng không được chỉ định đầy đủ. Hình dạng chứa None (độ dài trục không xác định) hoặc toàn bộ hình dạng là None (thứ hạng của tensor là không xác định).
Ngoại trừ tf.RaggedTensor , các hình dạng như vậy sẽ chỉ xuất hiện trong ngữ cảnh của các API xây dựng đồ thị, biểu tượng của TensorFlow:
Thêm trên DTypes
Để kiểm tra kiểu dữ liệu của tf.Tensor , hãy sử dụng thuộc tính Tensor.dtype .
Khi tạo tf.Tensor từ một đối tượng Python, bạn có thể tùy chọn chỉ định kiểu dữ liệu.
Nếu bạn không, TensorFlow chọn một kiểu dữ liệu có thể đại diện cho dữ liệu của bạn. TensorFlow chuyển đổi số nguyên Python thành tf.int32 và số dấu phẩy động Python thành tf.float32 . Nếu không, TensorFlow sử dụng các quy tắc tương tự mà NumPy sử dụng khi chuyển đổi thành mảng.
Bạn có thể truyền từ loại này sang loại khác.
the_f64_tensor = tf.constant([2.2, 3.3, 4.4], dtype=tf.float64)
the_f16_tensor = tf.cast(the_f64_tensor, dtype=tf.float16)
# Now, cast to an uint8 and lose the decimal precision
the_u8_tensor = tf.cast(the_f16_tensor, dtype=tf.uint8)
print(the_u8_tensor)
tf.Tensor([2 3 4], shape=(3,), dtype=uint8)
Phát thanh truyền hình
Broadcasting là một khái niệm được vay mượn từ tính năng tương đương trong NumPy . Nói tóm lại, trong một số điều kiện nhất định, các dây căng nhỏ hơn được "kéo căng" tự động để phù hợp với các dây căng lớn hơn khi chạy các hoạt động kết hợp trên chúng.
Trường hợp đơn giản và phổ biến nhất là khi bạn cố gắng nhân hoặc thêm một tenxơ vào một đại lượng vô hướng. Trong trường hợp đó, vô hướng được phát sóng để có cùng hình dạng với đối số kia.
x = tf.constant([1, 2, 3])
y = tf.constant(2)
z = tf.constant([2, 2, 2])
# All of these are the same computation
print(tf.multiply(x, 2))
print(x * y)
print(x * z)
tf.Tensor([2 4 6], shape=(3,), dtype=int32) tf.Tensor([2 4 6], shape=(3,), dtype=int32) tf.Tensor([2 4 6], shape=(3,), dtype=int32)
Tương tự như vậy, các trục có độ dài 1 có thể được kéo dài ra để khớp với các đối số khác. Cả hai đối số có thể được kéo dài trong cùng một phép tính.
Trong trường hợp này, ma trận 3x1 được nhân theo phần tử với ma trận 1x4 để tạo ra ma trận 3x4. Lưu ý cách số 1 đứng đầu là tùy chọn: Hình dạng của y là [4] .
# These are the same computations
x = tf.reshape(x,[3,1])
y = tf.range(1, 5)
print(x, "\n")
print(y, "\n")
print(tf.multiply(x, y))
tf.Tensor( [[1] [2] [3]], shape=(3, 1), dtype=int32) tf.Tensor([1 2 3 4], shape=(4,), dtype=int32) tf.Tensor( [[ 1 2 3 4] [ 2 4 6 8] [ 3 6 9 12]], shape=(3, 4), dtype=int32)
Một phép cộng được phát: a [3, 1] lần a [1, 4] cho một [3,4] |
|---|
 |
Đây là hoạt động tương tự mà không cần phát sóng:
x_stretch = tf.constant([[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3]])
y_stretch = tf.constant([[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4]])
print(x_stretch * y_stretch) # Again, operator overloading
tf.Tensor( [[ 1 2 3 4] [ 2 4 6 8] [ 3 6 9 12]], shape=(3, 4), dtype=int32)
Hầu hết thời gian, phát sóng hiệu quả cả về thời gian và không gian, vì hoạt động phát sóng không bao giờ hiện thực hóa các bộ căng mở rộng trong bộ nhớ.
Bạn sẽ thấy việc phát sóng trông như thế nào bằng cách sử dụng tf.broadcast_to .
print(tf.broadcast_to(tf.constant([1, 2, 3]), [3, 3]))
tf.Tensor( [[1 2 3] [1 2 3] [1 2 3]], shape=(3, 3), dtype=int32)
Không giống như một op toán học, ví dụ, broadcast_to không làm gì đặc biệt để tiết kiệm bộ nhớ. Ở đây, bạn đang thực hiện tensor.
Nó có thể trở nên phức tạp hơn. Phần này trong cuốn sách Sổ tay Khoa học Dữ liệu Python của Jake VanderPlas cho thấy nhiều thủ thuật truyền phát hơn (một lần nữa trong NumPy).
tf.convert_to_tensor
Hầu hết các hoạt động, như tf.matmul và tf.reshape lấy các đối số của lớp tf.Tensor . Tuy nhiên, bạn sẽ nhận thấy trong trường hợp trên, các đối tượng Python có hình dạng giống như tensor được chấp nhận.
Hầu hết, nhưng không phải tất cả, các hoạt động gọi convert_to_tensor trên các đối số không phải tensor. Có một sổ đăng ký chuyển đổi và hầu hết các lớp đối tượng như danh sách ndarray , TensorShape , Python và tf.Variable sẽ tự động chuyển đổi.
Xem tf.register_tensor_conversion_function để biết thêm chi tiết và nếu bạn có loại của riêng mình, bạn muốn tự động chuyển đổi thành tensor.
Ragged Tensors
Một tensor với số phần tử thay đổi dọc theo một số trục được gọi là "rapped". Sử dụng tf.ragged.RaggedTensor cho dữ liệu bị rách.
Ví dụ: Đây không thể được biểu diễn như một tensor thông thường:
A tf.RaggedTensor , hình dạng: [4, None] |
|---|
 |
ragged_list = [
[0, 1, 2, 3],
[4, 5],
[6, 7, 8],
[9]]
try:
tensor = tf.constant(ragged_list)
except Exception as e:
print(f"{type(e).__name__}: {e}")
ValueError: Can't convert non-rectangular Python sequence to Tensor.
Thay vào đó, hãy tạo tf.RaggedTensor bằng tf.ragged.constant :
ragged_tensor = tf.ragged.constant(ragged_list)
print(ragged_tensor)
<tf.RaggedTensor [[0, 1, 2, 3], [4, 5], [6, 7, 8], [9]]>
Hình dạng của tf.RaggedTensor sẽ chứa một số trục có độ dài không xác định:
print(ragged_tensor.shape)
(4, None)
Dây căng
tf.string là một dtype , có nghĩa là bạn có thể biểu diễn dữ liệu dưới dạng chuỗi (mảng byte có độ dài thay đổi) trong tensor.
Các chuỗi là nguyên tử và không thể được lập chỉ mục như các chuỗi Python. Chiều dài của chuỗi không phải là một trong các trục của tensor. Xem tf.strings để biết các hàm để thao tác với chúng.
Đây là một tensor chuỗi vô hướng:
# Tensors can be strings, too here is a scalar string.
scalar_string_tensor = tf.constant("Gray wolf")
print(scalar_string_tensor)
tf.Tensor(b'Gray wolf', shape=(), dtype=string)
Và một vectơ của chuỗi:
Một vectơ của chuỗi, hình dạng: [3,] |
|---|
 |
# If you have three string tensors of different lengths, this is OK.
tensor_of_strings = tf.constant(["Gray wolf",
"Quick brown fox",
"Lazy dog"])
# Note that the shape is (3,). The string length is not included.
print(tensor_of_strings)
tf.Tensor([b'Gray wolf' b'Quick brown fox' b'Lazy dog'], shape=(3,), dtype=string)
Trong bản in trên, tiền tố b chỉ ra rằng tf.string dtype không phải là một chuỗi unicode, mà là một chuỗi byte. Xem Hướng dẫn Unicode để biết thêm về cách làm việc với văn bản unicode trong TensorFlow.
Nếu bạn chuyển các ký tự unicode, chúng được mã hóa utf-8.
tf.constant("🥳👍")
<tf.Tensor: shape=(), dtype=string, numpy=b'\xf0\x9f\xa5\xb3\xf0\x9f\x91\x8d'>
Một số hàm cơ bản với chuỗi có thể được tìm thấy trong tf.strings , bao gồm tf.strings.split .
# You can use split to split a string into a set of tensors
print(tf.strings.split(scalar_string_tensor, sep=" "))
tf.Tensor([b'Gray' b'wolf'], shape=(2,), dtype=string)
# ...but it turns into a `RaggedTensor` if you split up a tensor of strings,
# as each string might be split into a different number of parts.
print(tf.strings.split(tensor_of_strings))
<tf.RaggedTensor [[b'Gray', b'wolf'], [b'Quick', b'brown', b'fox'], [b'Lazy', b'dog']]>
Chia ba chuỗi, hình dạng: [3, None] |
|---|
 |
Và tf.string.to_number :
text = tf.constant("1 10 100")
print(tf.strings.to_number(tf.strings.split(text, " ")))
tf.Tensor([ 1. 10. 100.], shape=(3,), dtype=float32)
Mặc dù bạn không thể sử dụng tf.cast để biến tensor chuỗi thành số, nhưng bạn có thể chuyển đổi nó thành byte và sau đó thành số.
byte_strings = tf.strings.bytes_split(tf.constant("Duck"))
byte_ints = tf.io.decode_raw(tf.constant("Duck"), tf.uint8)
print("Byte strings:", byte_strings)
print("Bytes:", byte_ints)
Byte strings: tf.Tensor([b'D' b'u' b'c' b'k'], shape=(4,), dtype=string) Bytes: tf.Tensor([ 68 117 99 107], shape=(4,), dtype=uint8)
# Or split it up as unicode and then decode it
unicode_bytes = tf.constant("アヒル 🦆")
unicode_char_bytes = tf.strings.unicode_split(unicode_bytes, "UTF-8")
unicode_values = tf.strings.unicode_decode(unicode_bytes, "UTF-8")
print("\nUnicode bytes:", unicode_bytes)
print("\nUnicode chars:", unicode_char_bytes)
print("\nUnicode values:", unicode_values)
Unicode bytes: tf.Tensor(b'\xe3\x82\xa2\xe3\x83\x92\xe3\x83\xab \xf0\x9f\xa6\x86', shape=(), dtype=string) Unicode chars: tf.Tensor([b'\xe3\x82\xa2' b'\xe3\x83\x92' b'\xe3\x83\xab' b' ' b'\xf0\x9f\xa6\x86'], shape=(5,), dtype=string) Unicode values: tf.Tensor([ 12450 12498 12523 32 129414], shape=(5,), dtype=int32)
Loại tf.string được sử dụng cho tất cả dữ liệu byte thô trong TensorFlow. Mô-đun tf.io chứa các chức năng để chuyển đổi dữ liệu sang và từ byte, bao gồm giải mã hình ảnh và phân tích cú pháp csv.
Lực căng thưa
Đôi khi, dữ liệu của bạn thưa thớt, giống như một không gian nhúng rất rộng. TensorFlow hỗ trợ tf.sparse.SparseTensor và các hoạt động liên quan để lưu trữ dữ liệu thưa thớt một cách hiệu quả.
Một tf.SparseTensor , hình dạng: [3, 4] |
|---|
 |
# Sparse tensors store values by index in a memory-efficient manner
sparse_tensor = tf.sparse.SparseTensor(indices=[[0, 0], [1, 2]],
values=[1, 2],
dense_shape=[3, 4])
print(sparse_tensor, "\n")
# You can convert sparse tensors to dense
print(tf.sparse.to_dense(sparse_tensor))
SparseTensor(indices=tf.Tensor( [[0 0] [1 2]], shape=(2, 2), dtype=int64), values=tf.Tensor([1 2], shape=(2,), dtype=int32), dense_shape=tf.Tensor([3 4], shape=(2,), dtype=int64)) tf.Tensor( [[1 0 0 0] [0 0 2 0] [0 0 0 0]], shape=(3, 4), dtype=int32)