Dasar-dasar TensorFlow: Tensor, Bentuk, Jenis, Sesi & Operatorso

Apa itu Tensor?

Nama Tensorflow diambil langsung dari kerangka intinya: Tensor. Di Tensorflow, semua komputasi melibatkan tensor. Tensor adalah vektor atau matriks berdimensi n yang mewakili semua jenis data. Semua nilai dalam tensor memiliki tipe data yang identik dengan bentuk yang diketahui (atau diketahui sebagian). Bentuk data adalah dimensi matriks atau array.

Tensor dapat berasal dari data input atau hasil komputasi. Dalam TensorFlow, semua operasi dilakukan di dalam grafik. Grafik adalah serangkaian komputasi yang berlangsung secara berurutan. Setiap operasi disebut simpul op dan saling terhubung.

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

Dalam Pembelajaran Mesin, model diberi daftar objek yang disebut vektor fitur. Vektor fitur dapat berupa tipe data apa pun. Vektor fitur biasanya akan menjadi input utama untuk mengisi tensor. Nilai-nilai ini akan mengalir ke simpul op melalui tensor dan hasil operasi/perhitungan ini akan membuat tensor baru yang selanjutnya akan digunakan dalam operasi baru. Semua operasi ini dapat dilihat dalam grafik.

Representasi Tensor

Di TensorFlow, tensor adalah kumpulan vektor fitur (yaitu array) dengan n-dimensi. Misalnya, jika kita memiliki matriks 2×3 dengan nilai dari 1 sampai 6, kita menulis:

TensorFlow merepresentasikan matriks ini sebagai:

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

Jika kita membuat matriks tiga dimensi dengan nilai dari 1 sampai 8, kita mendapatkan:

TensorFlow merepresentasikan matriks ini sebagai:

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

Catatan: Tensor dapat direpresentasikan dengan skalar atau dapat berbentuk lebih dari tiga dimensi. Hanya saja lebih rumit untuk memvisualisasikan tingkat dimensi yang lebih tinggi.

Jenis Tensor

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

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

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

• tf.Variabel
• tf.konstan
• tf.placeholder
• tf.SparseTensor

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

Sebelum kita melanjutkan tutorialnya, pastikan Anda mengaktifkan lingkungan conda dengan TensorFlow. Kami menamai lingkungan ini hello-tf.

Untuk pengguna MacOS:

source activate hello-tf

Untuk Windows pengguna:

activate hello-tf

Setelah Anda selesai melakukannya, Anda siap 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)

# 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 tensor. Setiap objek tensor didefinisikan dengan atribut tensor 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)

Tensor dimensi 1 dapat dibuat sebagai berikut:

## Rank 1r1_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 bentuk TensorFlow hanya terdiri dari 1 kolom.

Untuk membuat array dengan 2 dimensi tensor, Anda perlu menutup tanda kurung setelah setiap baris. Periksa contoh bentuk Keras 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 mempunyai 2 baris dan 2 kolom yang diisi dengan nilai 1, 2, 3, 4.

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

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

Matriksnya terlihat seperti gambar dua.

Bentuk tensor

Saat Anda mencetak tensor, TensorFlow menebak bentuknya. Namun, Anda bisa mendapatkan bentuk tensor dengan properti bentuk TensorFlow.

Di bawah ini, Anda membuat matriks yang diisi dengan angka dari 10 hingga 15 dan Anda memeriksa bentuk 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)

Properti ini juga berfungsi untuk matriks. Di sini, Anda membuat matriks 10×10 yang diisi dengan 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 tertentu untuk membuat vektor angka satu. Matriks m_shape berdimensi 3×2. Anda dapat membuat tensor dengan 3 baris yang diisi oleh angka satu dengan kode berikut:

# 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 dapat membuat vektor 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 hanya dengan satu matriks

print(tf.ones(m_shape.shape))

Keluaran

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

Jenis data

Properti kedua dari tensor adalah tipe data. Tensor hanya dapat memiliki satu jenis data dalam satu waktu. Tensor hanya dapat memiliki satu jenis data. Anda dapat mengembalikan tipe dengan properti dtype.

print(m_shape.dtype)

Keluaran

<dtype: 'int32'>

Dalam beberapa kesempatan, Anda ingin mengubah tipe data. Di TensorFlow, hal ini dimungkinkan dengan metode tf.cast.

Example

Di bawah ini, tensor float diubah menjadi integer menggunakan metode cast.

# 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: 'float32'>
<dtype: 'int32'>

TensorFlow memilih tipe data secara otomatis ketika argumen tidak ditentukan selama pembuatan tensor. TensorFlow akan menebak jenis data apa yang paling mungkin. Misalnya, jika Anda meneruskan sebuah teks, ia akan menebak itu adalah sebuah string dan mengubahnya menjadi string.

Membuat operator

Beberapa operator TensorFlow yang Berguna

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. Anda akan menggunakan metode TensorFlow untuk menghitung kuadrat suatu angka. Operasi ini mudah karena hanya diperlukan satu argumen untuk membuat tensor.

Kuadrat suatu bilangan dibangun dengan tf.sqrt(x) dengan x sebagai bilangan mengambang.

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

Keluaran

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

Catatan: Output mengembalikan objek tensor dan bukan hasil kuadrat 2. Dalam contoh, Anda mencetak definisi tensor dan bukan evaluasi aktual operasi. Di bagian berikutnya, Anda akan mempelajari cara kerja TensorFlow untuk menjalankan operasi.

Berikut ini adalah daftar operasi yang umum digunakan. Idenya sama. Setiap operasi memerlukan satu atau lebih argumen.

• tf.tambahkan(a, b)
• tf.kurangi(a, b)
• tf.kalikan(a, b)
• tf.div(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)

Penjelasan Kode

Buat dua tensor:

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

Anda menjumlahkan kedua tensor.

Melihat: kedua tensor harus memiliki bentuk yang sama. Anda dapat melakukan perkalian pada dua tensor.

# 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. Ini tidak banyak gunanya. Data selalu datang dengan nilai yang berbeda, untuk menangkapnya, Anda dapat menggunakan kelas Variabel. Ini akan mewakili sebuah node di mana nilainya selalu berubah.

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

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.

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

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

Keluaran

(1, 2)

Pada contoh kedua, Anda membuat variabel dengan satu baris dan dua kolom. Anda perlu menggunakan [1,2] untuk membuat dimensi variabel

Nilai awal tensor ini adalah nol. Misalnya, saat Anda melatih model, Anda harus memiliki nilai awal untuk menghitung bobot fitur. Di bawah, Anda menetapkan nilai awal ini ke 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 dapat meneruskan nilai tensor konstan dalam sebuah variabel. Anda membuat tensor konstan dengan metode tf.constant(). Anda menggunakan tensor ini untuk menginisialisasi variabel.

Nilai pertama variabel adalah 10, 20, 30 dan 40. Tensor baru akan berbentuk 2×2.

# Create a 2x2 matrixtensor_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 memiliki tujuan memberi makan tensor. Placeholder digunakan untuk menginisialisasi data agar mengalir di dalam tensor. Untuk menyediakan placeholder, Anda perlu menggunakan metode feed_dict. Placeholder akan diberikan hanya dalam satu sesi.

Pada contoh berikutnya, Anda akan melihat cara membuat placeholder dengan metode tf.placeholder. Di sesi berikutnya, Anda akan belajar memberi placeholder dengan nilai tensor aktual.

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

Komponen	Deskripsi
Grafik	Grafik merupakan hal mendasar dalam TensorFlow. Semua operasi matematika (ops) dilakukan di dalam grafik. Anda dapat membayangkan grafik sebagai proyek tempat semua operasi dilakukan. Node mewakili ops ini, node dapat menyerap atau membuat tensor baru.
tensor	Tensor mewakili data yang bergerak di antara operasi. Anda telah melihat sebelumnya cara menginisialisasi tensor. Perbedaan antara konstanta dan variabel adalah nilai awal variabel akan berubah seiring waktu.
sesi	Sesi akan menjalankan operasi dari grafik. Untuk memasukkan nilai tensor ke grafik, Anda perlu membuka sesi. Di dalam sesi, Anda harus menjalankan operator untuk membuat output.

Grafik dan sesi bersifat independen. Anda dapat menjalankan sesi dan mendapatkan nilai untuk digunakan nanti untuk perhitungan lebih lanjut.

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 akan terjadi dalam sesi tersebut. Setelah selesai, Anda harus menutup sesi.

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

Keluaran

[8]

Penjelasan kode

• tf.Session(): Membuka sesi. Semua operasi akan berjalan dalam sesi tersebut
• run(multiply): jalankan operasi yang dibuat pada langkah 2.
• print(result_1): Terakhir, Anda dapat mencetak hasilnya
• close(): Menutup sesi

Hasilnya adalah 8 yang merupakan perkalian x dan y.

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

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

Keluaran

[8]

Dalam konteks sesi, Anda dapat menggunakan metode eval() untuk menjalankan operasi. Metode ini setara dengan run(). Metode ini 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 kosong secara default, bahkan setelah Anda membuat tensor. Anda perlu menginisialisasi variabel jika ingin menggunakan variabel tersebut. Objek tf.global_variables_initializer() perlu dipanggil untuk menginisialisasi nilai suatu variabel. Objek ini secara eksplisit akan menginisialisasi semua variabel. Ini berguna sebelum Anda melatih model.

Anda dapat memeriksa nilai variabel yang Anda buat sebelumnya. Perhatikan bahwa Anda perlu menggunakan 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 Anda buat sebelumnya dan memberinya nilai sebenarnya. Anda perlu meneruskan data ke metode feed_dict.

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.

Penjelasan Kode

• impor numpy sebagai np: Impor perpustakaan numpy untuk membuat datanya
• tf.pow(data_placeholder_a, 2): Buat operasi
• np.random.rand(1, 10): Membuat array data acak
• feed_dict={data_placeholder_a: data}: Memberi makan 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 bergantung pada pendekatan jenius untuk menyajikan operasi. Semua perhitungan direpresentasikan dengan skema aliran data. Grafik aliran data telah dikembangkan untuk melihat ketergantungan data antara operasi individual. Rumus atau algoritme matematika dibuat dari sejumlah operasi yang berurutan. Grafik merupakan cara yang mudah untuk memvisualisasikan bagaimana perhitungan dikoordinasikan.

Grafik menunjukkan a simpul dan tepiNode adalah representasi dari suatu operasi, yaitu unit komputasi. Edge adalah tensor, yang dapat menghasilkan tensor baru atau menggunakan data input. Hal ini bergantung pada ketergantungan antara operasi individual.

Struktur grafik menghubungkan operasi-operasi (yaitu simpul-simpul) dan bagaimana operasi-operasi tersebut dijalankan. Perhatikan bahwa grafik tidak menampilkan output dari operasi-operasi, grafik hanya membantu memvisualisasikan hubungan antara operasi-operasi individual.

Mari kita lihat contohnya.

Bayangkan Anda ingin mengevaluasi fungsi berikut:

TensorFlow akan membuat grafik untuk menjalankan fungsi tersebut. Grafiknya terlihat seperti ini:

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

Misalnya, Anda dapat melihat operasi penambahan tidak dapat dilakukan sebelum dan . Grafik menjelaskan bahwa hal itu akan:

1. menghitung dan :
2. tambahkan 1) bersama-sama
3. tambahkan ke 2)
4. tambahkan 3) ke

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

Penjelasan Kode

• 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, kita memilih untuk menjaga nilai variabel tetap. Kami juga membuat tensor konstanta yang disebut c yang merupakan parameter konstanta dalam fungsi f. Dibutuhkan nilai tetap sebesar 5. Dalam grafik, Anda dapat melihat parameter ini dalam tensor yang disebut konstanta.

Kami juga membuat tensor konstan untuk daya dalam operator tf.pow(). Itu tidak perlu. Kami melakukannya agar Anda dapat melihat nama tensor dalam grafik. Itu adalah lingkaran yang disebut persegi.

Dari grafik tersebut, Anda dapat memahami apa yang akan terjadi pada tensor dan bagaimana tensor dapat menghasilkan output 66.

Kode di bawah ini mengevaluasi fungsi dalam suatu 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]

Kesimpulan

TensorFlow bekerja di sekitar:

• Grafik: Lingkungan komputasi yang berisi operasi dan tensor
• Tensor: Mewakili data (atau nilai) yang akan mengalir dalam grafik. Ini adalah tepi dalam grafik
• Sesi: Izinkan eksekusi operasi

Buat tensor konstan

konstan	obyek
D0	tf.konstan(1, tf.int16)
D1	tf.konstan([1,3,5], tf.int16)
D2	tf.konstan([ [1, 2], [3, 4] ],tf.int16)
D3	tf.konstan([ [[1, 2],[3, 4], [5, 6]] ], tf.int16)

Buat operator

Buat operator	obyek
a + b	tf.tambahkan(a, b)
a * b	tf.kalikan(a, b)

Buat tensor variabel

Buat variabel	obyek
nilai acak	tf.get_variable("var", [1, 2])
nilai pertama yang diinisialisasi	tf.get_variable(“var_init_2”, dtype=tf.int32, penginisialisasi=[ [1, 2], [3, 4] ])

Buka sesi

sesi	obyek
Buat sesi	tf.Sesi()
Jalankan sesi	tf.Sesi.jalankan()
Evaluasi tensor	variabel_nama.eval()
Tutup sesi	sess.tutup()
Sesi demi blok	dengan tf.Session() sebagai sess: