Tensorflow 2.0 bagian 1

By | October 23, 2021
640 Views

Yuk Belajar Dasar Tensorflow versi 2.0 merupakan tulisan berserial yang akan membahas secara khusus pemanfaatan tensorflow untuk deep machine learning. Ikuti saja tulisan ini agar kalian bisa belajar dengan mudah. Tensorflow memudahkan kita dalam bekerja dalam melakukan machine learning terutama pada algoritma descent gradient,  selain itu kita juga pernah bahas mengenai linear regression  semuanya berkaitan dengan sesi training yang melibatkan learning rate. Namun itu semuanya bisa kita permudah menggunakan tensor!

Sinopsis

Apa itu tensor?

Seringkali kita mendengar kata “tensorflow”, sebagian besar dari kita akan langsung berpikir dengan istilah “deep learning”. Padahal, tensorflow sebenarnya adalah tools untuk melakukan komputasi numerik (lebih luas daripada hanya sekedar untuk deep learning). Misalkan terkait komputasi numerik adalah seperti mengerjakan operasi matriks, melakukan (convex) function optimization, menghitung gradient atau hessian (turuan kedua) dari sebuah fungsi, dsb. Isu-isu yang ada di deep learning, seperti representation learning, optimization, operasi matriks dan tensor, adalah proses komputasi numerik yang dapat dilakukan dengan tensorflow. Selain tensorflow, ada banyak tools yang serupa seperti MATLAB, Octave, Numpy, Scipy, dsb. Namun, tensoflow menawarkan berbagai macam kelebihan, yang utama adalah seperti kemampuan untuk melakukan komputasi yang memanfaatkan banyak CPUs dan GPUs (saat ini hanya NVidia Cuda yang support).

Menurut wikipedia, Dalam matematika, tensor adalah objek aljabar yang menggambarkan sebuah hubungan (multilinear) di antara sehimpunan objek aljabar yang berhubungan dengan sebuah ruang vektor. Objek yang bisa dipetakan oleh tensor di antaranya vektor (yang biasanya, tapi tidak selalu, digambarkan sebagai anak panah dengan panjang dan arah tertentu) dan skalar (yang merupakan bilangan biasa seperti bilangan real), dan, bahkan tensor lainnya. Tensor bisa memiliki berbagai bentuk – contohnya: skalar dan vektor (yang merupakan tensor paling sederhana), vektor dual, pemetaan multilinear antar ruang vektor, dan operasi-operasi seperti hasil kali titik. Tensor didefinisikan tidak tergantung pada basis, meskipun tensor sering disebut berdasarkan komponennya dengan basis yang berhubungan dengan suatu sistem koordinat.

 

Hal pertama yang perlu dipahami ketika ingin menggunakan tensorflow adalah konsep computational graph. Di tensorflow, graf dibentuk dari 2 komponen berikut:

  • Node merepresentasikan operasi matematika/numerik
  • Sisi merepresentasikan aliran tensor (bentuk umum dari matriks, maupun vektor)

Selain itu sebuah tensor memiliki properties sebagai berikut

  • tipe data: data type (float32, int32, or string)
  • ataupun  berbentuk dimensi lain (shape)

Special tensors:

  1. tf.Variable,
  2. tf.constant,
  3. tf.placeholder,
  4. tf.SparseTensor

Variable

  • cara terbaik untuk mewakili represent shared, persistent state yang dapat dengan mudah dimanipulasi
  • Variabel dimanipulasi melalui kelas tf.Variable
  • Variabel pada dasarnya adalah tensor wrapper

Oiya lupa, saya menggunakan tensor versi 2.0 keatas ya, lebih tepatnya saya cek dengan perintah berikut

import tensorflow as tf
tf.compat.v1.disable_eager_execution()

tf.__version__
Out[2]: '2.2.0-rc3'

Berikut cara membuat variable dengan tf.Variable

s = tf.Variable(2,name="scalar",dtype=tf.float32)
m = tf.Variable([[0,1],[2,3]],name="matrix",dtype=tf.float32)
W = tf.Variable(tf.zeros([784,10]),dtype=tf.float32)

atau dengan cara tf.get_variable agak sedikit berbeda harus menggunakan scope

with tf.compat.v1.variable_scope("something",reuse=tf.compat.v1.AUTO_REUSE) as scope:
    v = tf.compat.v1.get_variable("matrix",initializer = tf.constant([[0,1],[2,3]]),dtype=tf.int32)

untuk memanggil nya menggunakan session

with tf.compat.v1.Session() as sess:
    sess.run(tf.compat.v1.global_variables_initializer())
    print(sess.run(v))

hasil

[[0 1]
 [2 3]]

 

Inisialisasi variable

Setelah dibuat variabel diatas, saatnya di inisialisasi

with tf.compat.v1.Session() as sess:
    sess.run(tf.compat.v1.global_variables_initializer())
    print(s,m,W)

Mengenal Session

Coba kalian ketikan kode berikut

import tensorflow as tf
tf.compat.v1.disable_eager_execution()
a = tf.add(3,5)
print(a)

maka bukan angka 8 yang dihasilkan, melainkan hanya sebuah object tensor

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

Bagaimana cara mendapatkan nilai a?

See also  Teknik Segmentasi Pelanggan

Buat sesi, tetapkan ke variabel sess sehingga kita bisa memanggilnya nanti Dalam sesi tersebut, evaluasi grafik untuk mengambil nilai a

Apa itu tf.Session()

  • Mengenkapsulasi lingkungan tempat objek Operasi berada dieksekusi, dan objek Tensor dievaluasi
  • Memungkinkan untuk mengeksekusi graph atau bagian graph lain
  • Mengalokasikan sumber daya (pada satu atau lebih mesin) untuk itu dan memegang nilai aktual dari hasil dan variabel antara

maka kode untuk mendapatkan nilai a yaitu melalui graph berikut

sess = tf.compat.v1.Session()
print(sess.run(a))
sess.close()

atau dengan cara berikut tanpa perlu melakukan close karena bekerja dalam sebuah scope

with tf.compat.v1.Session() as sess:
    print(sess.run(a))

Constants

Tensor juga punya nilai contants yaitu nilai yang bersifat tetap, dengan bentuk sebagai berikut

tf.constant(value,
            dtype=None,
            shape=None,
            name='Const',
            verify_shape=False
            )

Contoh inisialisasi nya

a = tf.constant([2,2],name='a')
b = tf.constant([[0,1],[2,3]],name='b')

Value Random

Untuk membuat bilangan random, dapat kita panggil melalui perintah berikut

  • tf.random_normal
  • tf.truncated_normal
  • tf.random_uniform
  • tf.random_shuffle
  • tf.random_crop
  • tf.multtnomial
  • tf.random_gamma
  • tf.set_random_seed

 

Contoh penggunakan lain penggunaan get_variable pada tensor – reuse

with tf.compat.v1.variable_scope("something",reuse=tf.compat.v1.AUTO_REUSE) as scope:
    v = tf.compat.v1.get_variable("matrix",initializer = tf.constant([[0,1],[2,3]]),dtype=tf.int32)
    

with tf.compat.v1.variable_scope('layer1', reuse=tf.compat.v1.AUTO_REUSE):
    w1 = tf.Variable(tf.compat.v1.random_normal(shape=[2,2], mean=0, stddev=1), name='w1')
    w2 = tf.compat.v1.get_variable(name = 'w',initializer = tf.compat.v1.random_normal(shape=[3,3], mean=0, stddev=1))


#cara memanggilnya
with tf.compat.v1.Session() as sess:
    sess.run(tf.compat.v1.global_variables_initializer())
    print(sess.run(v))
    print(sess.run(w1))
    print(sess.run(w2))

hasil

[[0 1]
 [2 3]]
[[-0.3409669   0.06048483]
 [ 0.95758605 -0.26818076]]
[[-0.35172918 -0.82968616 -1.0565814 ]
 [-0.97585136  2.0807433   1.1484636 ]
 [-0.15226632  0.5405805   2.5497248

Oiya, saya belum begitu paham mengapa harus menggunakan scope! bila tidak menggunakan cara diatas akan terjadi error bahwa variables is exist!

  • tf.AUTO_REUSE: itu akan membuat variabel jika tidak ada, dan mengembalikannya sebaliknya.
  • Saat kita menggunakan tf.variable_scope (), kita harus menggunakan fungsi tf.get_variable () untuk membuat atau mengembalikan variabel yang ada. Jika Anda menggunakan tf.Variable (), itu akan membuat variabel baru tidak peduli berapa nilai parameter reuse.

ref: https://www.tutorialexample.com/understand-tf-variable_scope-reuse-mode-for-beginners-tensorflow-tutorial/

https://qastack.id/programming/35919020/whats-the-difference-of-name-scope-and-a-variable-scope-in-tensorflow

Contoh lain

Sebagai contoh, operasi matematika:

    \[  y = \sqrt{a} + (b \times c) \]

dapat divisualisasikan dengan computational graph berikut.

Yup, saya menggunakan tensorflow versi 2.2.0, karena ntar ada attribut session yang dipanggil akan error pada versi 2. Kita coba saja yuk

    \[ y = x + 1 \]

dengan x=5

x = tf.constant(5)
y = x + 1

Perhatikan bahwa x, y, 1, dan 5 adalah tensor dengan masing-masing mempunyai dimensi R^1. Jika kalian mencoba untuk mencetak nilai y ke layar dengan perintah berikut, nilai 6 tidak akan muncul di layar. Ini karena y adalah object tensor.

print(y)
tf.Tensor(6, shape=(), dtype=int32)

Saya akan jelaskan perbedaan antara tensorflow versi 1.0 dan 2.0

a. Tensorflow versi 1.0

with tf.Session() as sess:
    y_ = sess.run(y)
    print (y_)

b. Tensorflow versi 2.0 keatas yaitu

import tensorflow as tf
import numpy as np

tf.compat.v1.disable_eager_execution()

x = tf.constant(5)
y = x + 1

with tf.compat.v1.Session() as sess:
    y_ = sess.run(y)
    print (y_)

hasilnya yaitu

6

Apa perbedaan antara versi 1.0 dan 2.0

Perbedaan antar versi 1 dan 2 mengingat bahwa TensorFlow 2.0 dikembangkan dari awal untuk memudahkan pengembangan, pelatihan, dan penerapan model pembelajaran mesin. Di TensorFlow 2.0, banyak API baru telah diperkenalkan dan banyak API lama telah dihapus atau tidak digunakan lagi, karena kalau tidak menggunakan perintah diatas akan terjadi pesan error

TensorFlow 2.0 has no attribute session

Ini bukan error atau masalah dengan TensorFlow 2.0, sebenarnya fungsi sesi telah dihapus dari TensorFlow 2.0 demi eksekusi yang cepat. Jika kalian mencoba menjalankan kode berikut:

See also  Support Vector Machine - SVM

sess = tf.Session()

Untuk mendapatkan objek Session di TensorFlow 2.0 maka akan muncul error “TensorFlow 2.0 has no attribute session”. Jadi, error ini muncul di TensorFlow 2.0 karena ini telah dihapus dalam mode eager execution. Berikut adalah contoh sederhana program Hello World yang ditulis dalam TensorFlow 1.x: (padahal kalian akan eksekusi pada tensorflow 2.0)

import tensorflow as tf
msg = tf.constant('Say Hello to TensorFlow!')
sess = tf.Session()
print(sess.run(msg))

Jika kalian mencoba menjalankan TensorFlow 2.0, error berikut akan muncul:

AttributeError                            
Traceback (most recent call last) <ipython-input-2-ab14ce10de0b> in <module>()
      1 import tensorflow as tf
      2 msg = tf.constant('Say Hello to TensorFlow!')
----> 3 sess = tf.Session()
      4 print(sess.run(msg))

AttributeError: module 'tensorflow' has no attribute 'Session'

Solusinya kalian dapat menggunakan utilitas ini yaitu eager execution secara default diaktifkan di TensorFlow 2.0. Eager execution TensorFlow 2.0 adalah lingkungan pemrograman yang sangat diperlukan dengan menjalankan operasi tanpa membangun grafik. Operasi di TensorFlow 2.0 mengembalikan nilai konkret seperti di Python. Selama proses ini tidak ada grafik yang dibuat dan komputasi segera dilakukan. Ini membuat pengembangan dan debugging program menjadi lebih mudah.

Untuk alasan kompatibilitas dan untuk menjalankan kode TensorFlow 1.x TensorFlow 2.0 menyediakan opsi untuk menonaktifkan eager execution untuk menjalankan kode lama. Tetapi disarankan untuk mengupgrade kode kalian ke TensorFlow 2.0. Berikut ini kode yang harus diperbaiki bila kalian menggunakan TensorFlow 2.0:

import tensorflow as tf

tf.compat.v1.disable_eager_execution()

hello = tf.constant('Hello, Welcome')

sess = tf.compat.v1.Session()

print(sess.run(hello))

Operator Tensor

Berikut jenis operator yang didukung oleh tensor

Operasi Arimatika tensor

Berikut operasi arimatika tensor

  1. tf.abs
  2. tf.negative
  3. tf.sign
  4. tf.recoprocal
  5. tf.square
  6. tf.round
  7. tf.sqrt
  8. tf.rsqrt
  9. tf.pow
  10. tf.exp

Data Tipe Tensor

Berikut tipe dasar tensor

  • tf .float16 :16-bit half-precision floating-point.
  • tf .float32 : 32-bit single-precision floating-point.
  • tf .float64 : 64-bit double-precision floating-point.
  • tf .bfloat16 : 16-bit truncated floating-point.
  • tf . complex64 : 64-bit single-precision complex.
  • tf .complex128 : 128-bit double-precision complex. tf. .int8 : 8-bit signed integer.
  • tf .uint8 : 8-bit unsigned integer.
  • tf .uint16 : 16-bit unsigned integer.
  • tf. .int16 : 16-bit signed integer.
  • tf . int32 : 32-bit signed integer.
  • tf . int64 : 64-bit signed integer.
  • tf . bool : Boolean.
  • tf st ring : String.
  • tf .qint8 : Quantized 8-bit signed integer.
  • tf .quint8 : Quantized 8-bit unsigned integer.
  • tf .qinti6 : Quantized 16-bit signed integer.
  • tf .quint16 : Quantized 16-bit unsigned integer.
  • tf .qint32 : Quantized 32-bit signed integer.
  • tf. resource : Handle to a mutable resource.

Kita lanjutkan lagi mengenai operasi dimensi yang lebih tinggi

Contoh berikut adalah contoh operasi yang melibatkan tensor dengan dimensi (shape) yang lebih tinggi. Pada contoh di bawah,

    \[ W \in R^{3 \times 2} \]

    \[ u \in R^{2 \times 1} \]

    \[ v \in R^{3 \times 1}  \]

yaitu

    \[ W = \begin{pmatrix} 1 & 1 \\ 2 & 2 \\ 3 & 3 \end{pmatrix} \]

    \[ u = \begin{pmatrix} 2 \\ 1 \end{pmatrix} \]

maka perkalian antar matrix v = w \times u yaitu

W = tf.constant([[1,1],[2,2],[3,3]]) # shape W : (3, 2)
u = tf.constant([[2],[1]]) # shape u : (2,1)

# tf.matmul(., .) adalah operasi perkalian matriks
v = tf.matmul(W, u) # harusnya shape v : (3, 1)

with tf.compat.v1.Session() as sess:
    print (sess.run(v))

hasil

[[3]
 [6]
 [9]]

Contoh lainnya operasi tensor

Kalian bisa coba kode berikut, untuk lebih memahami cara kerja tensor pada tensorflow

import tensorflow as tf
import numpy as np
tf.compat.v1.disable_eager_execution()

matrix1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype = 'int32')
matrix2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype = 'int32')

print ('matrix1: \n ',matrix1)
print ('matrix2: \n ',matrix2)

matrix1 = tf.constant(matrix1)
matrix2 = tf.constant(matrix2)
matrix_product = tf.matmul(matrix1, matrix2)
matrix_sum = tf.add(matrix1,matrix2)
matrix_3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype = 'float32')
print ('matrix3: \n ',matrix_3)

matrix_det = tf.compat.v1.matrix_determinant(matrix_3)
with tf.compat.v1.Session() as sess:
   result1 = sess.run(matrix_product)
   result2 = sess.run(matrix_sum)
   result3 = sess.run(matrix_det)

print ('result1: \n ',result1)
print ('result2: \n ',result2)
print ('result3: \n ',result3)

hasilnya tensor diatas yaitu

matrix1: 
  [[2 2 2]
 [2 2 2]
 [2 2 2]]
matrix2: 
  [[1 1 1]
 [1 1 1]
 [1 1 1]]
matrix3: 
  [[2. 7. 2.]
 [1. 4. 2.]
 [9. 0. 2.]]
result1: 
  [[6 6 6]
 [6 6 6]
 [6 6 6]]
result2: 
  [[3 3 3]
 [3 3 3]
 [3 3 3]]
result3: 
  55.999992

Sama saja koq seperti operasi array di numpy, sekarang kita menggunakan placeholder

See also  Aplikasi Kmeans clustering dengan Matlab

Placeholder sebagai Input ke Graf Komputasi

Ada apa dengan tf.constant()? constant disimpan dalam definisi grafik sehingga Hal ini membuat loading graph menjadi berat ketika konstanta besar selain itu hanya untuk tipe primitif. Pada contoh sebelumnya, input dari graf komputasi bersifat konstan. Jika ingin membuat graf komputasi tanpa bergantung dengan isi input, kita dapat menggunakan placeholder. Placeholder nantinya akan diisi dengan nilai tensor yang sesungguhnya ketika kita akan mengeksekusi graf tersebut. Definisikan fungsi f (x, y) = 2 * x + y tanpa mengetahui nilai x atau y maka  xy adalah placeholder untuk nilai aktual.

tf.compat.v1.placeholder(dtype,shape=None, name=None)

Contoh penggunaan placeholder

a = tf.compat.v1.placeholder(tf.float32,shape=[3]) 
#bikin constant
b = tf.constant([5,5,5],tf.float32)
c = a + b
with tf.compat.v1.Session() as sess:
    result = sess.run(c,feed_dict={a:[1,2,3]})
    print(result)

hasilnya

[6. 7. 8.]

Anda bisa memberi feed_dict tensor apa pun yang dapat diberi nilai. Placeholder hanyalah cara untuk menunjukkan bahwa sesuatu harus diberi nilai/feed/umpan. Yuk kita buat placeholder

# membuat placeholder dengan shape (2,2)
M = tf.compat.v1.placeholder(shape=[2, 2], dtype=tf.int32)

kemudian untuk operasi nya hanya perkalian saja

N = tf.constant([[1,0],[0,1]])
Z = tf.matmul(M, N)

yaitu

    \[  z = M \times N \]

Misalkan M akan diisi dengan variabel berikut

    \[ data1 = \begin{pmatrix} 2 & 3\\ 3 & 1 \end{pmatrix} \]

maka perkalian antar matrix diatas dengan placeholder yaitu

# input dalam bentuk Numpy Array
data_1 = np.array([[2,3],[3,1]])

# coba jalankan dengan ganti M dengan nilai yang ingin dimasukkan
with tf.compat.v1.Session() as sess:
    print (sess.run(Z, feed_dict={M: data_1}))

hasilnya

[[2 3]
 [3 1]]

Placeholder untuk menerima data dari user

Placeholder juga dapat menerima input dari dataset csv / excel, misalkan kita akan gunakan dataset ini, berikut penggunaan placeholder

import tensorflow as tf
import numpy as np
import pandas as pd

tf.compat.v1.disable_eager_execution()

data = pd.read_excel('data.xlsx')
x = data['suhu']


n_data = len(x)
#bikin placeholder
x_pl = tf.compat.v1.placeholder(tf.float32, [n_data,], name="x_pl")
x_input = x_pl

with tf.compat.v1.Session() as sess:
    print (sess.run(x_input,feed_dict={x_pl:x}))

hasil

[24. 22. 21. 20. 22. 19. 20. 23. 24. 25. 21. 20. 20. 19. 25. 27. 28. 25.
 26. 24. 27. 23. 24. 23. 22. 21. 26. 25. 26. 27.]

Tensor Gradient-based Optimization (Gradient Descent)

Pada bab sebelumya telah dibahas gradient descent, yuk kita bahas ulang lagi saja, kalian bisa lihat berikut. Mari kita mulai dengan eksperimen sederhana dengan melakukan perhitungan langsung di balik penurunan gradien , perhatikan persamaan kuadrat berikut

    \[y(x) = x^{2}+x-6\]

atau dalam persamaan turunan terhadap x yaitu

(1)   \begin{equation*}  \begin{split} \frac{df}{dx} & = x^{2}+x-6 \\ & =2 x+1 \end{split} \end{equation*}

untuk mencari x ketika y=0 atau mencapai y minimum yaitu

(2)   \begin{equation*}  \begin{split} 2x+1 & =0 \\ 2x & =-1 \\ x & =-\frac{1}{2} \end{split} \end{equation*}

Sekarang nilai x = -\frac{1}{2} akan kita masukan ke persamaan

    \[y(x) = x^{2}+x-6\]

menghasilkan nilai y=-6.25. Yuk kita gambar langsung saja, kalian bisa melihat nilai global minimum nya

Kita mencoba melakukan beberapa kali iterasi untuk melakukan untuk mencari nilai y minimal, maka saya menggunakan rumus berikut

    \[x_{i+1} = x_{i} - \alpha \frac{df}{dx}\]

Dengan menggunakan persamaan diatas dimana:

  • x_{i} adalah nilai tebakan awal /starting point dalam hal ini kita pakai angka x_{i}=1
  • \alpha adalah nilai  kecepatan pemelajaran (membuat “peluruhan lambat”)
  • \frac{df}{dx} adalah turunan dari fungsi  (berlawanan arah dengan turunan)
  • x_{i+1} adalah nilai tebakan berikutnya

Lanjut lagi ke berikutnya

Leave a Reply

Your email address will not be published.




Enter Captcha Here :