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 seragam (disebut dtype ). Anda dapat melihat semua dtypes didukung di tf.dtypes.DType .

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

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

Dasar-dasar

Mari kita 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 satu 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 dua 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)
Sebuah skalar, bentuk: [] Sebuah vektor, bentuk: [3] Sebuah matriks, bentuk: [3, 2]
Sebuah skalar, nomor 4Baris dengan 3 bagian, masing-masing berisi nomor.Kotak 3x2, dengan setiap sel berisi nomor.

Tensor mungkin memiliki lebih banyak sumbu; di sini adalah tensor dengan tiga 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 dua sumbu.

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

Anda dapat mengonversi tensor ke array NumPy 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 mengandung float dan int, tetapi memiliki banyak jenis lainnya, termasuk:

  • bilangan kompleks
  • string

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

Anda dapat mengerjakan matematika dasar tentang tensor, termasuk penjumlahan, perkalian 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.3105854e-01]
 [9.9987662e-01 1.2339458e-04]], shape=(2, 2), dtype=float32)

Tentang bentuk

Tensor memiliki bentuk. Beberapa kosakata:

  • Bentuk : Panjang (jumlah elemen) dari masing-masing sumbu tensor.
  • Rank : Jumlah sumbu tensor. Sebuah skalar memiliki rank 0, sebuah vektor memiliki rank 1, sebuah matriks memiliki rank 2.
  • Sumbu atau Dimensi : Dimensi tertentu dari sebuah tensor.
  • Ukuran : Jumlah total item dalam tensor, vektor bentuk produk.

Objek Tensor dan tf.TensorShape memiliki properti yang nyaman 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 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

Sementara sumbu sering disebut dengan indeksnya, Anda harus selalu melacak arti masing-masing. Seringkali sumbu diurutkan dari global ke lokal: Sumbu batch terlebih dahulu, diikuti oleh dimensi spasial, dan fitur untuk setiap lokasi terakhir. Dengan cara ini, vektor fitur adalah wilayah memori yang berdekatan.

Urutan sumbu khas
Melacak apa setiap sumbu. Tensor 4-sumbu mungkin: Batch, Width, Height, Features

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 mulai dari 0
  • indeks negatif menghitung 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]

Pengindeksan dengan skalar menghilangkan sumbu:

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

Pengindeksan dengan : slice menjaga sumbu:

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 melewati beberapa indeks.

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

print(rank_2_tensor.numpy())

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

Melewati bilangan bulat 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 kumpulan
Tensor 3x2x5 dengan semua nilai pada indeks-4 dari sumbu terakhir yang dipilih.Nilai yang dipilih dikemas ke dalam tensor 2 sumbu.

Baca panduan pemotongan tensor untuk mempelajari cara menerapkan pengindeksan untuk memanipulasi elemen individual dalam tensor Anda.

Memanipulasi Bentuk

Membentuk kembali tensor sangat bermanfaat.

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

Anda dapat membentuk kembali 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 urutan memori "baris-utama" gaya-C, di mana penambahan 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 urutannya 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 masuk akal adalah untuk menggabungkan atau membagi sumbu yang berdekatan (atau menambah/menghapus 1 detik).

Untuk tensor 3x2x5 ini, membentuk 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 kembali menjadi (3x2)x5Data yang sama dibentuk kembali menjadi 3x(2x5)

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

Mengganti 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 buruk.
Anda tidak dapat menyusun ulang sumbu, gunakan tf.transpose untuk ituApa pun yang mencampur potongan data bersama-sama mungkin salah.Bentuk baru harus pas.

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

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

Lebih lanjut tentang DTypes

Untuk memeriksa tipe data tf.Tensor gunakan properti Tensor.dtype .

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

Jika tidak, TensorFlow akan memilih tipe 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 yang digunakan NumPy saat mengonversi ke array.

Anda dapat mentransmisikan dari jenis ke jenis.

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 pas dengan tensor yang lebih besar saat menjalankan operasi gabungan pada tensor tersebut.

Kasus paling sederhana dan paling umum adalah ketika Anda mencoba mengalikan atau menambahkan tensor ke skalar. Dalam hal ini, skalar disiarkan menjadi 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 juga, sumbu dengan panjang 1 dapat direntangkan agar sesuai dengan argumen lainnya. Kedua argumen dapat diregangkan dalam perhitungan yang sama.

Dalam hal ini matriks 3x1 adalah elemen-bijaksana dikalikan dengan matriks 1x4 untuk menghasilkan matriks 3x4. Perhatikan bagaimana 1 di depan 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 yang disiarkan: a [3, 1] kali a [1, 4] menghasilkan [3,4]
Menambahkan matriks 3x1 ke matriks 4x1 menghasilkan matriks 3x4

Berikut adalah 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 waktu dan ruang, karena operasi siaran tidak pernah mewujudkan tensor yang diperluas dalam memori.

Anda melihat seperti apa siaran menggunakan 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)

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

Ini bisa menjadi lebih rumit. Bagian dari buku Jake VanderPlas Buku Pegangan Ilmu Data Python ini menunjukkan lebih banyak trik penyiaran (sekali lagi di NumPy).

tf.convert_to_tensor

Kebanyakan operasi, seperti tf.matmul dan tf.reshape mengambil argumen dari kelas tf.Tensor . Namun, Anda akan melihat dalam kasus di atas, objek Python yang berbentuk seperti tensor diterima.

Sebagian besar, tetapi tidak semua, ops memanggil convert_to_tensor pada argumen non-tensor. Ada daftar 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 detail selengkapnya, dan jika Anda memiliki tipe sendiri, Anda ingin secara otomatis mengonversi ke tensor.

Tensor Ragged

Sebuah tensor dengan variabel jumlah elemen sepanjang beberapa sumbu disebut "ragged". Gunakan tf.ragged.RaggedTensor untuk data yang tidak rata.

Misalnya, Ini tidak dapat direpresentasikan sebagai tensor biasa:

Sebuah tf.RaggedTensor , bentuk: [4, None]
Tensor kasar 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.

Alih-alih membuat tf.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]]>

Bentuk tf.RaggedTensor akan berisi beberapa sumbu dengan panjang 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.

String bersifat atomik dan tidak dapat diindeks seperti string Python. Panjang string bukan salah satu sumbu tensor. Lihat tf.strings untuk fungsi untuk memanipulasinya.

Berikut ini 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:

Sebuah vektor string, bentuk: [3,]
Panjang string bukan 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)

Dalam 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 melewati karakter unicode, mereka 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 senar terbelah, bentuk: [3, None]
Memisahkan beberapa string 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 dtype digunakan untuk semua data byte mentah di TensorFlow. Modul tf.io berisi fungsi untuk mengonversi data ke dan dari byte, termasuk decoding gambar dan parsing csv.

Tensor jarang

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

Sebuah tf.SparseTensor , bentuk: [3, 4]
Kotak 3x4, dengan nilai hanya dalam 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)