Trang này được dịch bởi Cloud Translation API.
Switch to English

Giới thiệu về Tensors

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub Tải xuống sổ tay
import tensorflow as tf
import numpy as np

Tensors là mảng nhiều chiều có kiểu đồng nhất (gọi là kiểu dtype ). Bạn có thể xem tất cả các loại dtypes được hỗ trợ tại tf.dtypes.DType .

Nếu bạn đã quen thuộc với NumPy , tensors (loại) giống như np.arrays .

Tất cả các tensor là bất biến giống 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 tenxơ 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ó 1 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 tenxơ "ma trận" hoặc "hạng 2" có 2 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]
Một vô hướng, số 4Dòng có 3 phần, mỗi phần chứa một số.Lưới 3x2, với mỗi ô chứa một số.

Tensors có thể có nhiều trục hơn, đây là một tensor có 3 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 2 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:

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.3105860e-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 kích thước của một tensor.
  • Xếp hạng : Số kích thướ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 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 tf.TensorShapetf.TensorShape có các thuộc tính thuận tiện để truy cập các đối tượng sau:

rank_4_tensor = tf.zeros([3, 2, 4, 5])
Một tensor cấp 4, hình dạng: [3, 2, 4, 5]
Một hình dạng tensor giống như một vectơ.Một tensor 4 trục
print("Type of every element:", rank_4_tensor.dtype)
print("Number of dimensions:", 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 dimensions: 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

Trong khi các trục thường được gọi bằng các chỉ số của chú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
Theo dõi từng trục là gì. Một bộ căng 4 trục có thể là: Batch, Width, Height, Freatures

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ỏ thứ nguyên:

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 : slice giữ nguyên thứ nguyên:

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 bộ căng 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 một trục chính xác giống như trong trường hợp một trục á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ô
Một tensor 3x2x5 với tất cả các giá trị tại chỉ số-4 của trục cuối cùng được chọn.Các giá trị đã chọn được đóng gói thành một tensor 2 trục.

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 on each dimension
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, 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 / tf.reshape 1 s).

Đối với tensor 3x2x5 này, định hình 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.
Một tensor 3x2x5Dữ liệu tương tự được định hình lại thành (3x2) x5Dữ liệu tương tự được định hình lại thành 3x (2x5)

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 có ích gì nếu bạn không tôn trọng thứ tự của các trục.

Việc hoán đổ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 không thể sắp xếp lại các trục, hãy sử dụng tf.transpose cho điều đóBất cứ điều gì trộn các phần dữ liệu với nhau có thể là sai.Hình dạng mới phải vừa vặn chính xác.

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 (chiều dài của một kích thước không xác định) hoặc hình dạng là None (thứ hạng của tensor không được biết).

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 một tf.Tensor 's kiểu dữ liệu sử dụng các Tensor.dtype tài sản.

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 thì 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 những đ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 thứ nguyên có kích thước 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]
Thêm ma trận 3x1 vào ma trận 4x1 dẫn đến ma trận 3x4

Đâ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 khi 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.matmultf.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 có 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]
Máy kéo xé có 2 trục, mỗi hàng có thể có chiều dài khác nhau.
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 chứa các kích thước 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 kích thước của tensor. Xem tf.strings để biết các hàm để thao tác 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,]
Chiều dài chuỗi không phải là một trong các trục của tensor.
# 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]
Tách nhiều chuỗi trả về một tf.RaggedTensor

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ố, bạn có thể chuyển đổi nó thành byte, 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]
Lưới 3x4, chỉ có các giá trị trong hai ô.
# 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)