Apa itu Tensor di TensorFlow? Bentuk, Tipe & Operatorso

Apa itu Tensor?

Nama TensorFlow TensorFlow diturunkan langsung dari objek intinya: tensor. Di TensorFlow, setiap komputasi melibatkan tensor. Tensor adalah vektor atau matriks berdimensi n yang merepresentasikan semua jenis data. Semua nilai dalam tensor memiliki tipe data yang identik dengan bentuk yang diketahui (atau sebagian diketahui), dan bentuk data tersebut adalah dimensi matriks atau array.

Tensor dapat berasal dari data masukan atau dari hasil komputasi. Di TensorFlow, semua operasi dilakukan di dalam sebuah graf. Graf adalah sekumpulan komputasi yang berlangsung secara berurutan. Setiap operasi disebut node op, dan node-node tersebut terhubung satu sama lain.

Grafik tersebut menguraikan operasi dan koneksi antar simpul. Namun, grafik tersebut tidak menampilkan nilainya. Tepi antara simpul adalah tensor, yaitu cara untuk mengisi operasi dengan data.

Dalam pembelajaran mesin, model diberi input berupa daftar objek yang disebut vektor fitur. Vektor fitur dapat berupa tipe data apa pun, dan biasanya merupakan input utama yang mengisi tensor. Nilai-nilai ini mengalir ke node operasi melalui tensor, dan hasil dari operasi tersebut menciptakan tensor baru, yang kemudian digunakan dalam operasi baru. Semua operasi ini dapat dilihat dalam grafik.

Representasi Tensor

Dalam TensorFlow, tensor adalah kumpulan vektor fitur (yaitu, sebuah array) dengan n dimensi. Misalnya, jika kita memiliki matriks 2×3 dengan nilai dari 1 hingga 6, kita menuliskannya sebagai matriks seperti yang ditunjukkan di bawah ini:

TensorFlow merepresentasikan matriks ini sebagai:

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

Jika kita membuat matriks tiga dimensi dengan nilai dari 1 hingga 8, data yang sama akan digambarkan sebagai sebuah kotak dengan dua sisi yang bertumpuk:

TensorFlow merepresentasikan matriks ini sebagai:

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

Catatan: Sebuah tensor dapat direpresentasikan dengan skalar atau dapat memiliki bentuk lebih dari tiga dimensi. Hanya saja, memvisualisasikan tingkat dimensi yang lebih tinggi jauh lebih sulit.

Jenis Tensor

Di TensorFlow, semua komputasi melewati satu atau lebih tensor. tf.Tensor adalah objek dengan tiga properti:

• Label unik (nama)
• Dimensi (bentuk)
• Tipe data (tipe d)

Setiap operasi yang Anda lakukan dengan TensorFlow melibatkan manipulasi tensor. Ada empat tipe tensor utama yang dapat Anda buat:

• tf.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

Dalam tutorial ini, Anda akan mempelajari cara membuat sebuah tf.constant dan tf.Variable.

Satu hal yang perlu diingat sebelum Anda menjalankan kode: tutorial ini mengikuti API TensorFlow 1.x asli, di mana grafik dibangun terlebih dahulu dan dieksekusi kemudian di dalam sebuah sesi. TensorFlow 2 berjalan secara eager secara default, sehingga beberapa simbol di bawah ini dipindahkan atau dihapus. Setiap simbol tersebut masih dapat diakses melalui tf.compat.v1 namespace, dan tabel tersebut memetakan masing-masing ke padanannya di zaman modern.

Sebelum mengikuti tutorial, pastikan Anda telah mengaktifkan lingkungan conda yang telah terpasang TensorFlow. Lingkungan ini bernama hello-tf.

Untuk macOS pengguna:

source activate hello-tf

Untuk Windows pengguna:

activate hello-tf

Setelah Anda melakukan itu, Anda siap untuk mengimpor TensorFlow.

# Import tf
import tensorflow as tf

Buat Tensor n-Dimensi

Anda mulai dengan membuat tensor dengan satu dimensi yaitu skalar.

Untuk membuat tensor, Anda dapat menggunakan tf.constant() seperti yang ditunjukkan pada contoh bentuk tensor TensorFlow di bawah ini:

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`

Untuk membuat tensor berdimensi 0, jalankan kode berikut.

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

Keluaran

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

Ketiga bagian dari output tersebut dipetakan ke tiga properti tensor, seperti yang dijelaskan dalam versi beranotasi di bawah ini.

Anda juga dapat memberi nama tensor sendiri dengan cara berikut: name argumen.

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

Keluaran

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

Setiap tensor ditampilkan berdasarkan nama tensornya. Setiap objek tensor didefinisikan dengan atribut seperti label unik (nama), dimensi (bentuk), dan tipe data TensorFlow (dtype).

Anda dapat menentukan tensor dengan nilai desimal atau string dengan mengubah tipe datanya.

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

Keluaran

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

Sebuah tensor berdimensi 1 dapat dibuat sebagai berikut:

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

Keluaran

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

Anda dapat melihat bahwa bentuk TensorFlow hanya terdiri dari 1 kolom.

Untuk membuat array tensor dengan 2 dimensi, Anda perlu menutup tanda kurung setelah setiap baris. Perhatikan contoh bentuk tensor di bawah ini.

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

Keluaran

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

Matriks tersebut memiliki 2 baris dan 2 kolom yang diisi dengan nilai 1, 2, 3, dan 4.

Matriks dengan 3 dimensi dibangun dengan menambahkan satu tingkat tanda kurung lagi.

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

Keluaran

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

Hasilnya sesuai dengan diagram kotak tiga dimensi yang ditunjukkan sebelumnya dalam tutorial ini.

Bentuk Tensor

Saat Anda mencetak tensor, TensorFlow akan menyimpulkan bentuknya. Namun, Anda dapat membaca bentuknya secara langsung dengan TensorFlow. shape milik.

Di bawah ini, Anda membuat matriks yang diisi dengan angka dari 10 hingga 15 dan Anda memeriksa bentuknya. m_shape.

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

Keluaran

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

Matriks mempunyai 3 baris dan 2 kolom.

TensorFlow memiliki perintah yang berguna untuk membuat vektor atau matriks yang diisi dengan 0 atau 1. Misalnya, jika Anda ingin membuat tensor 1-D dengan bentuk tertentu 10, diisi dengan 0, Anda dapat menjalankan kode di bawah ini:

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

Keluaran

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

Sifat ini juga berlaku untuk matriks. Di sini, Anda membuat matriks 10×10 yang diisi dengan angka 1.

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

Keluaran

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

Anda dapat menggunakan bentuk matriks yang diberikan untuk membuat vektor yang berisi angka satu. Matriks tersebut m_shape memiliki dimensi 3×2, sehingga kode berikut membuat tensor dengan 3 baris yang berisi angka satu:

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

Keluaran

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

Jika Anda memasukkan nilai 1 ke dalam tanda kurung, Anda akan membuat vektor berisi angka satu yang sama dengan jumlah kolom dalam matriks. m_shape.

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

Keluaran

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

Terakhir, Anda dapat membuat matriks 3×2 yang seluruhnya berisi angka satu.

print(tf.ones(m_shape.shape))

Keluaran

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

Jenis Data

Sifat kedua dari tensor adalah tipe data. Sebuah tensor hanya dapat menyimpan satu tipe data dalam satu waktu, dan Anda dapat membaca tipe tersebut dengan dtype milik.

print(m_shape.dtype)

Keluaran

<dtype: &#x27;int32'>

Terkadang, Anda ingin mengubah tipe data. Di TensorFlow, hal itu dimungkinkan dengan tf.cast Metode.

Example

Di bawah ini, tensor float dikonversi menjadi bilangan bulat dengan cast Metode.

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

Keluaran

<dtype: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow memilih tipe data secara otomatis ketika argumen tidak ditentukan selama pembuatan tensor. TensorFlow menebak tipe data yang paling mungkin: jika Anda memberikan teks, misalnya, ia akan menyimpulkan sebagai string.

membuat Operator

Beberapa TensorFlow yang Berguna Operatorso

Anda tahu cara membuat tensor dengan TensorFlow. Sekarang saatnya mempelajari cara melakukan operasi matematika.

TensorFlow berisi semua operasi dasar. Anda dapat memulai dengan yang sederhana dan menggunakan metode TensorFlow untuk menghitung akar kuadrat suatu angka. Operasi ini mudah karena hanya satu argumen yang diperlukan untuk membangun tensor.

Akar kuadrat suatu bilangan dibentuk dengan tf.sqrt(x), dengan x sebagai bilangan floating-point.

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

Keluaran

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

Catatan: Output yang dikembalikan adalah objek tensor dan bukan akar kuadrat dari 2. Dalam contoh ini, Anda mencetak definisi tensor dan bukan evaluasi sebenarnya dari operasi tersebut. Di bagian Sesi di bawah ini, Anda akan mempelajari bagaimana TensorFlow mengeksekusi operasi tersebut.

Berikut adalah daftar operasi yang umum digunakan. Idenya sama: setiap operasi membutuhkan satu atau lebih argumen.

• tf.add(a, b)
• tf.subtract(a, b)
• tf.multiply(a, b)
• tf.divide(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

Example

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

Keluaran

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

Code Penjelasan

Buat dua tensor:

• satu tensor dengan 1 dan 2
• satu tensor dengan 3 dan 4

Anda menjumlahkan kedua tensor.

Perhatikan bahwa kedua tensor harus memiliki bentuk yang sama. Anda juga dapat melakukan perkalian pada kedua tensor tersebut.

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

Keluaran

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

Variabel

Sejauh ini, Anda hanya membuat tensor konstan, yang kegunaannya terbatas jika berdiri sendiri. Data selalu datang dengan nilai yang berbeda, dan untuk menangkap hal itu Anda dapat menggunakan kelas Variable. Sebuah variabel merepresentasikan sebuah node yang nilainya berubah seiring waktu.

Untuk membuat variabel, Anda dapat menggunakan tf.get_variable() Metode.

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.

Sebagai contoh, kode di bawah ini membuat variabel dua dimensi dengan dua nilai acak. Secara default, TensorFlow mengembalikan nilai acak. Anda memberi nama variabel tersebut var.

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

Keluaran

(1, 2)

Dalam contoh ini, Anda membuat variabel dengan satu baris dan dua kolom, jadi Anda memberikan [1, 2] sebagai dimensi variabel.

Nilai awal tensor juga bisa nol. Misalnya, saat melatih model, Anda memerlukan nilai awal sebelum menghitung bobot fitur. Di bawah ini, Anda mengatur nilai awal tersebut menjadi nol.

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

Keluaran

(1, 2)

Anda juga dapat meneruskan nilai tensor konstan ke dalam sebuah variabel. Anda membuat tensor konstan dengan metode tersebut. tf.constant() dan menggunakan tensor tersebut untuk menginisialisasi variabel.

Nilai pertama variabel tersebut adalah 10, 20, 30, dan 40. Tensor baru tersebut memiliki bentuk 2×2.

# Create a 2x2 matrix
tensor_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)

Keluaran

(2, 2)

placeholder

Placeholder berfungsi untuk memasukkan data ke dalam tensor. Placeholder menginisialisasi data yang akan mengalir ke dalam tensor. Untuk memasukkan placeholder, Anda menggunakan feed_dict argumen, dan placeholder hanya dimasukkan dalam satu sesi.

Pada contoh berikutnya, Anda akan melihat cara membuat placeholder dengan metode tersebut. tf.placeholderDi bagian Sesi, Anda akan belajar cara memasukkan nilai tensor aktual ke dalam placeholder.

Sintaksnya adalah:

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)

Keluaran

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

sesi

TensorFlow bekerja dengan 3 komponen utama:

• Grafik
• tensor
• sesi

Grafik dan sesi bersifat independen. Anda dapat menjalankan sebuah sesi dan menyimpan nilainya untuk perhitungan lebih lanjut di kemudian hari.

Pada contoh di bawah ini, Anda akan:

• Buat dua tensor
• Buat operasi
• Buka sesi
• Cetak hasilnya

Langkah 1) Anda membuat dua tensor x dan y

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

Langkah 2) Anda membuat operator dengan mengalikan x dan y

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

Langkah 3) Anda membuka sesi. Semua perhitungan terjadi di dalam sesi tersebut, dan setelah selesai, Anda perlu menutupnya.

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

Keluaran

[8]

Code penjelasan

• tf.Session()Buka sesi. Semua operasi berlangsung di dalam sesi tersebut.
• run(multiply): jalankan operasi yang dibuat pada langkah 2
• print(result_1)Terakhir, Anda dapat mencetak hasilnya.
• close()Tutup sesi

Hasilnya adalah 8 yang merupakan perkalian x dan y.

Cara lain untuk membuat sesi adalah di dalam blok. Keuntungannya adalah sesi akan ditutup secara otomatis.

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

Keluaran

[8]

Dalam konteks sesi, Anda dapat menggunakan eval() metode untuk menjalankan operasi. Ini setara dengan run() dan membuat kode lebih mudah dibaca.

Anda dapat membuat sesi dan melihat nilai di dalam tensor yang Anda buat sejauh ini.

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

Keluaran

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

Variabel secara default kosong, bahkan setelah Anda membuat tensor. Anda perlu menginisialisasi variabel sebelum dapat menggunakannya. Objek tersebut tf.global_variables_initializer() Fungsi ini dipanggil untuk menginisialisasi nilai setiap variabel sekaligus, yang berguna sebelum Anda melatih model.

Anda dapat memeriksa nilai variabel yang telah Anda buat sebelumnya. Perhatikan bahwa Anda perlu menggunakan perintah `run` untuk mengevaluasi tensor.

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

Keluaran

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

Anda dapat menggunakan placeholder yang telah Anda buat sebelumnya dan mengisinya dengan nilai sebenarnya. Anda perlu memasukkan data tersebut ke dalam feed_dict argumen.

Misalnya, Anda akan mengambil pangkat 2 dari 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.

Code Penjelasan

• import numpy as np: Impor JumlahPy perpustakaan untuk membuat data
• tf.pow(data_placeholder_a, 2)Buat operasinya
• np.random.rand(1, 10): Buat larik data acak
• feed_dict={data_placeholder_a: data}Isi placeholder dengan data

Keluaran

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

Grafik

TensorFlow menyajikan setiap operasi dengan skema aliran data. Grafik aliran data dirancang untuk memperlihatkan ketergantungan data antar operasi individual. Suatu rumus matematika atau algoritma terdiri dari sejumlah operasi berurutan, dan grafik adalah cara yang mudah untuk memvisualisasikan bagaimana komputasi tersebut dikoordinasikan.

Grafik tersebut menunjukkan simpul dan sisi. Simpul adalah representasi dari suatu operasi, yaitu unit komputasi. Sisi adalah tensor: ia dapat menghasilkan tensor baru atau mengonsumsi data masukan, tergantung pada ketergantungan antara operasi-operasi individual.

Struktur grafik menghubungkan operasi (yaitu, simpul) bersama-sama dan menunjukkan bagaimana masing-masing operasi diberi input. Perhatikan bahwa grafik tidak menampilkan output dari operasi; grafik hanya membantu memvisualisasikan koneksi antar operasi.

Mari kita lihat sebuah contoh. Bayangkan Anda ingin mengevaluasi fungsi berikut:

TensorFlow membangun sebuah grafik untuk mengeksekusi fungsi tersebut. Grafik tersebut terlihat seperti ini:

Anda dapat dengan mudah melihat jalur yang diambil tensor untuk mencapai tujuan akhir.

Misalnya, add node tidak dapat berjalan sebelum keduanya Mul ke Pow telah menghasilkan hasilnya. Grafik menunjukkan bahwa TensorFlow akan:

1. menghitung x·z di Mul simpul dan x² di Pow simpul
2. jumlahkan kedua hasil tersebut di dalam add simpul
3. tambahkan z ke jumlah tersebut di add_1 simpul
4. tambahkan konstanta 5 di add_2 simpul

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

Code Penjelasan

• x: Inisialisasi variabel bernama x dengan nilai konstanta 5
• z: Inisialisasi variabel bernama z dengan nilai konstanta 6
• c: Inisialisasi tensor konstanta yang disebut c dengan nilai konstanta 5
• square: Inisialisasi tensor konstan yang disebut square dengan nilai konstanta 2
• f: Bangun operatornya

Dalam contoh ini, nilai variabel dijaga tetap. Tensor konstanta c adalah parameter konstanta dalam fungsi f dan mengambil nilai tetap 5; pada grafik Anda dapat melihat parameter ini dalam tensor yang disebut konstanta.

Tensor konstan juga dibuat untuk daya dalam operator tersebut. tf.pow()Ini tidak wajib, tetapi artinya eksponen muncul di grafik sebagai lingkaran yang disebut persegi.

Dari grafik, Anda dapat mengikuti apa yang terjadi pada tensor dan mengapa fungsi tersebut mengembalikan 66: 5 × 6 ditambah 5² ditambah 6 ditambah 5 sama dengan 66.

Kode di bawah ini mengevaluasi fungsi di dalam sebuah sesi.

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)

Keluaran

[66]

Panduan Singkat Dasar-Dasar TensorFlow

Keempat tabel di bawah ini mengumpulkan setiap perintah yang digunakan dalam tutorial ini sehingga Anda dapat mencarinya tanpa harus menggulir kembali melalui contoh-contoh sebelumnya.

Buat tensor konstan

Buat operator

Buat tensor variabel

Buka sesi

Pertanyaan Umum Demo Slot