Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Pengantar Tensor

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan
import tensorflow as tf
import numpy as np

Tensor adalah array multi-dimensi dengan tipe yang seragam (disebut dtype ). Anda dapat melihat semua dtypes didukung ditf.dtypes.DType .

Jika Anda terbiasa dengan NumPy , tensor (jenis) seperti np.arrays .

Semua tensor tidak dapat diubah seperti nomor dan string Python: Anda tidak akan pernah dapat memperbarui konten tensor, hanya buat yang baru.

Dasar

Mari buat beberapa tensor dasar.

Berikut adalah tensor "skalar" atau "peringkat-0". Skalar berisi satu nilai, dan tidak ada "sumbu".

# 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)

Tensor "vektor" atau "peringkat-1" seperti daftar nilai. Sebuah vektor memiliki 1 sumbu:

# 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)

Tensor "matriks" atau "peringkat-2" memiliki 2 sumbu:

# 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)

Skalar, bentuk: [] Sebuah vektor, bentuk: [3] Sebuah matriks, bentuk: [3, 2]
Skalar, angka 4Garis dengan 3 bagian, masing-masing berisi nomor.Petak 3x2, dengan setiap sel berisi angka.

Tensor mungkin memiliki lebih banyak sumbu, berikut adalah tensor dengan 3 sumbu:

# 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)

Ada banyak cara untuk memvisualisasikan tensor dengan lebih dari 2 sumbu.

Tensor 3 sumbu, bentuk: [3, 2, 5]

Anda dapat mengonversi tensor menjadi array NumPy baik menggunakan np.array atau 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)

Tensor sering kali mengandung float dan int, tetapi memiliki banyak tipe lainnya, termasuk:

  • bilangan kompleks
  • string

Kelas base tf.Tensor membutuhkan tensor menjadi "persegi panjang" --- yaitu, di sepanjang setiap sumbu, setiap elemen memiliki ukuran yang sama. Namun, ada jenis tensor khusus yang dapat menangani berbagai bentuk:

Anda dapat mengerjakan matematika dasar tentang tensor, termasuk penjumlahan, perkalian berdasarkan elemen, dan perkalian matriks.

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) 


Tensor digunakan dalam semua jenis operasi (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)

Tentang bentuk

Tensor memiliki bentuk. Beberapa kosakata:

  • Bentuk : Panjang (jumlah elemen) dari setiap dimensi tensor.
  • Rangking : Jumlah dimensi tensor. Skalar memiliki peringkat 0, vektor memiliki peringkat 1, matriks memiliki peringkat 2.
  • Axis atau Dimension : Dimensi tensor tertentu.
  • Ukuran : Jumlah total item di tensor, vektor bentuk produk

Objek tf.TensorShape dan tf.TensorShape memiliki properti yang mudah digunakan untuk mengakses ini:

rank_4_tensor = tf.zeros([3, 2, 4, 5])
Tensor peringkat-4, bentuk: [3, 2, 4, 5]
Bentuk tensor seperti vektor.Tensor 4 sumbu
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

Meskipun sumbu sering kali dirujuk oleh indeksnya, Anda harus selalu melacak artinya masing-masing. Seringkali sumbu diurutkan dari global ke lokal: Sumbu batch pertama, diikuti oleh dimensi spasial, dan fitur untuk setiap lokasi terakhir. Dengan cara ini vektor fitur adalah wilayah memori yang berdekatan.

Urutan sumbu tipikal
Pantau apa itu setiap sumbu. Tensor 4 sumbu bisa berupa: Batch, Width, Height, Freatures

Pengindeksan

Pengindeksan sumbu tunggal

TensorFlow mengikuti aturan pengindeksan Python standar, mirip dengan pengindeksan daftar atau string di Python , dan aturan dasar untuk pengindeksan NumPy.

  • indeks dimulai dari 0
  • indeks negatif dihitung mundur dari akhir
  • titik dua, : , digunakan untuk irisan: 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]

Mengindeks dengan skalar menghilangkan dimensi:

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

Mengindeks dengan slice : menjaga dimensi:

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]

Pengindeksan multi-sumbu

Tensor peringkat yang lebih tinggi diindeks dengan melewatkan beberapa indeks.

Aturan satu sumbu yang sama persis seperti pada kasus sumbu tunggal berlaku untuk setiap sumbu secara independen.

print(rank_2_tensor.numpy())
[[1. 2.]
 [3. 4.]
 [5. 6.]]

Meneruskan integer untuk setiap indeks hasilnya adalah skalar.

# Pull out a single value from a 2-rank tensor
print(rank_2_tensor[1, 1].numpy())
4.0

Anda dapat mengindeks menggunakan kombinasi bilangan bulat dan irisan:

# 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.]] 


Berikut adalah contoh dengan tensor 3 sumbu:

print(rank_3_tensor[:, :, 4])
tf.Tensor(
[[ 4  9]
 [14 19]
 [24 29]], shape=(3, 2), dtype=int32)

Memilih fitur terakhir di semua lokasi di setiap contoh dalam kelompok
Tensor 3x2x5 dengan semua nilai pada indeks-4 dari sumbu terakhir dipilih.Nilai yang dipilih dikemas ke dalam tensor 2 sumbu.

Memanipulasi Bentuk

Membentuk ulang tensor sangat bermanfaat.

# 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]

Anda dapat membentuk ulang tensor menjadi bentuk baru. Operasi tf.reshape cepat dan murah karena data yang mendasarinya tidak perlu diduplikasi.

# 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)

Data mempertahankan tata letaknya dalam memori dan tensor baru dibuat, dengan bentuk yang diminta, menunjuk ke data yang sama. TensorFlow menggunakan pengurutan memori "baris-mayor" gaya C, di mana kenaikan indeks paling kanan sesuai dengan satu langkah dalam memori.

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)

Jika Anda meratakan tensor, Anda dapat melihat urutan penataannya dalam memori.

# 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)

Biasanya satu-satunya penggunaan tf.reshape yang tf.reshape adalah untuk menggabungkan atau memisahkan sumbu yang berdekatan (atau menambah / menghapus 1 s).

Untuk tensor 3x2x5 ini, pembentukan kembali menjadi (3x2) x5 atau 3x (2x5) adalah hal yang wajar untuk dilakukan, karena irisan tidak bercampur:

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)

Beberapa bentuk yang bagus.
Tensor 3x2x5Data yang sama dibentuk ulang menjadi (3x2) x5Data yang sama dibentuk ulang menjadi 3x (2x5)

Pembentukan ulang akan "berfungsi" untuk setiap bentuk baru dengan jumlah elemen yang sama, tetapi tidak akan berguna jika Anda tidak menghormati urutan sumbu.

Menukar sumbu di tf.reshape tidak berfungsi, Anda perlu tf.transpose untuk itu.

# 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]

Beberapa bentuk kembali buruk.
Anda tidak dapat menyusun ulang sumbu, gunakan tf.transpose untuk ituApa pun yang mencampurkan potongan data menjadi satu mungkin salah.Bentuk baru harus pas.

Anda mungkin menemukan bentuk yang tidak sepenuhnya ditentukan. Entah bentuk tersebut berisi None (panjang dimensi tidak diketahui) atau bentuknya adalah None (peringkat tensor tidak diketahui).

Kecuali untuk tf.RaggedTensor , bentuk seperti itu hanya akan terjadi dalam konteks API pembuatan grafik simbolis TensorFlow:

Lebih lanjut tentang DTypes

Untuk memeriksa sebuah tf.Tensor 's tipe data penggunaanTensor.dtype properti.

Saat membuat tf.Tensor dari objek Python, Anda dapat secara opsional menentukan tipe data.

Jika tidak, TensorFlow akan memilih jenis data yang dapat mewakili data Anda. TensorFlow mengonversi bilangan bulat Python menjadi tf.int32 dan bilangan floating point Python menjadi tf.float32 . Jika tidak, TensorFlow menggunakan aturan yang sama dengan yang digunakan NumPy saat mengonversi ke array.

Anda dapat mentransmisikan dari tipe ke tipe.

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)

Penyiaran

Penyiaran adalah konsep yang dipinjam dari fitur yang setara di NumPy . Singkatnya, dalam kondisi tertentu, tensor yang lebih kecil "diregangkan" secara otomatis agar sesuai dengan tensor yang lebih besar saat menjalankan operasi gabungan padanya.

Kasus paling sederhana dan paling umum adalah saat Anda mencoba mengalikan atau menambahkan tensor ke skalar. Dalam hal ini, skalar disiarkan dengan bentuk yang sama dengan argumen lainnya.

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)

Demikian pula, dimensi 1 ukuran dapat direntangkan agar sesuai dengan argumen lainnya. Kedua argumen dapat diperpanjang dalam komputasi yang sama.

Dalam hal ini matriks 3x1 adalah elemen-bijaksana dikalikan dengan matriks 1x4 sehingga menghasilkan matriks 3x4. Perhatikan bagaimana awalan 1 adalah opsional: Bentuk y adalah [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)

Penambahan disiarkan: a [3, 1] dikalikan a [1, 4] menghasilkan [3,4]
Menambahkan matriks 3x1 ke matriks 4x1 menghasilkan matriks 3x4

Berikut operasi yang sama tanpa penyiaran:

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)

Sebagian besar waktu, penyiaran efisien ruang dan waktu, karena operasi siaran tidak pernah mewujudkan tensor yang diperluas dalam memori.

Anda melihat seperti apa penyiaran menggunakantf.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)

Tidak seperti operasi matematika, misalnya, broadcast_to tidak melakukan apa pun yang khusus untuk menghemat memori. Di sini, Anda mewujudkan tensor.

Ini bisa menjadi lebih rumit. Bagian dari buku Jake VanderPlas Python Data Science Handbook menunjukkan lebih banyak trik penyiaran (lagi-lagi di NumPy).

tf.convert_to_tensor

Sebagian besar ops, seperti tf.matmul dan tf.reshape menggunakan argumen kelas tf.Tensor . Namun, Anda akan melihat dalam kasus di atas, objek Python yang berbentuk seperti tensor diterima.

Sebagian besar, tetapi tidak semua, operasi memanggil convert_to_tensor pada argumen non-tensor. Ada registri konversi, dan sebagian besar kelas objek seperti ndarray NumPy, TensorShape , daftar Python, dan tf.Variable semuanya akan dikonversi secara otomatis.

Lihat tf.register_tensor_conversion_function untuk lebih jelasnya, dan jika Anda memiliki tipe Anda sendiri, Anda ingin mengonversi secara otomatis ke tensor.

Tensor compang-camping

Tensor dengan jumlah elemen variabel di sepanjang sumbu disebut "compang-camping". Gunakan tf.ragged.RaggedTensor untuk data compang-camping.

Misalnya, ini tidak dapat direpresentasikan sebagai tensor biasa:

Atf.RaggedTensor , bentuk: [4, None]
Tensor bergerigi 2 sumbu, setiap baris dapat memiliki panjang yang berbeda.
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.

Sebagai gantinya, buattf.RaggedTensor menggunakan 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]]>

Bentuktf.RaggedTensor berisi dimensi yang tidak diketahui:

print(ragged_tensor.shape)
(4, None)

Tensor string

tf.string adalah dtype , artinya Anda dapat merepresentasikan data sebagai string (array byte dengan panjang variabel) dalam tensor.

Stringnya atom dan tidak dapat diindeks seperti string Python. Panjang string bukan merupakan salah satu dimensi tensor. Lihat tf.strings untuk fungsi memanipulasinya.

Berikut adalah tensor string skalar:

# 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)

Dan vektor string:

Vektor string, bentuk: [3,]
Panjang senar bukanlah salah satu sumbu 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)

Pada cetakan di atas, awalan b menunjukkan bahwa tf.string dtype bukanlah string unicode, tetapi string-byte. Lihat Tutorial Unicode untuk mengetahui lebih lanjut tentang bekerja dengan teks unicode di TensorFlow.

Jika Anda memberikan karakter unicode, mereka akan dikodekan utf-8.

tf.constant("🥳👍")
<tf.Tensor: shape=(), dtype=string, numpy=b'\xf0\x9f\xa5\xb3\xf0\x9f\x91\x8d'>

Beberapa fungsi dasar dengan string dapat ditemukan di tf.strings , termasuk 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']]>

Tiga string terbelah, bentuk: [3, None]
Memisahkan beberapa string akan mengembalikan tf.RaggedTensor

Dan 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)

Meskipun Anda tidak dapat menggunakan tf.cast untuk mengubah tensor string menjadi angka, Anda dapat mengubahnya menjadi byte, lalu menjadi angka.

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)

tf.string digunakan untuk semua data byte mentah di TensorFlow. Modul tf.io berisi fungsi untuk mengonversi data ke dan dari byte, termasuk mendekode gambar dan mengurai csv.

Tensor jarang

Terkadang, data Anda jarang, seperti ruang penyematan yang sangat luas. TensorFlow mendukung tf.sparse.SparseTensor dan operasi terkait untuk menyimpan data jarang secara efisien.

A tf.SparseTensor , bentuk: [3, 4]
Kotak 3x4, dengan nilai hanya di dua sel.
# 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)