Lesson simple linear regression menggunakan TensorFlow akan membahas model linear dengan dua fitur input. Sama seperti pada lesson sebelumnya yaitu Basic Neural Network menggunakan NumPy.
Tujuan dari lesson ini adalah sebegai pengenalan TensorFlow. Oleh karena itu digunakan Simple Linear Regression yang sudah dibahas sebelumnya, dengan harapan Anda sudah memahami lesson tersebut.
Dengan demikian fokus dapat ditujukan untuk pengenalan TensorFlow dan memahami tahapan untuk membuat model.
#import module yang diperlukan
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
#tentukan jumlah observasi
observations = 100000
#generate data input dan target lalu simpan ke npz file
xs = np.random.uniform(low=-10, high=10, size=(observations,1))
zs = np.random.uniform(-10, 10, (observations,1))
generated_inputs = np.column_stack((xs,zs))
noise = np.random.uniform(-1, 1, (observations,1))
generated_targets = 2*xs - 3*zs + 5 + noise
np.savez('TFSimpleLinear', inputs=generated_inputs, targets=generated_targets)
#penjabaran model
input_size = 2
output_size = 1
inputs = tf.placeholder(tf.float32, [None, input_size])
targets = tf.placeholder(tf.float32, [None, output_size])
weights = tf.Variable(tf.random_uniform([input_size, output_size], minval=-0.1, maxval=0.1))
biases = tf.Variable(tf.random_uniform([output_size], minval=-0.1, maxval=0.1))
outputs = tf.matmul(inputs, weights) + biases
#definisikan objective function dan optimization method
mean_loss = tf.losses.mean_squared_error(labels=targets, predictions=outputs) / 2.
optimize = tf.train.GradientDescentOptimizer(learning_rate=0.05).minimize(mean_loss)
#inisialisasi session
sess = tf.InteractiveSession()
#inisialisasi variable
initializer = tf.global_variables_initializer()
sess.run(initializer)
#load data training
training_data = np.load('TFSimpleLinear.npz')
#model learning
for i in range(100):
_, curr_loss = sess.run([optimize, mean_loss],
feed_dict={inputs: training_data['inputs'], targets: training_data['targets']})
print(curr_loss)
#visualisasi model
out = sess.run([outputs],
feed_dict={inputs: training_data['inputs']})
plt.plot(np.squeeze(out), np.squeeze(training_data['targets']))
plt.xlabel('outputs')
plt.ylabel('targets')
plt.show()
Pembahasan Code
Langkah pertama adalah meng-import library-library pendukung. NumPy digunakan untuk membuat data, matplotlib untuk visualisasi grafik dan tensorflow adalah library utama untuk membuat model.
import numpy as np import matplotlib.pyplot as plt import tensorflow as tf
Langkah selanjutnya adalah generate data untuk input dan output. Langkah ini hanya digunakan untuk tujuan lesson ini saja, pada praktek didunia nyata, data real yang akan digunakan.
Data input memiliki 2 fitur yaitu xs dan zs yang digenerate otomatis menggunakan perintah np.random.uniform. Kemudia kedua variable tersebut akan digabungkan menjadi matrix 1000 x 2.
Selanjutnya target akan digenerate otomatis berdasarkan fungsi 2xs – 3zs + 5 + noise. Noise digunakan agar data target lebih random untuk mensimulasikan data pada dunia nyata.
Terakhir data tersebut akan disimpan kedalam file bernama TFSimpleLinear dengan ekstensi npz. File ini nanti akan digunakan untuk melatih model.
#tentukan jumlah observasi
observations = 100000
#generate data input dan target lalu simpan ke npz file
xs = np.random.uniform(low=-10, high=10, size=(observations,1))
zs = np.random.uniform(-10, 10, (observations,1))
generated_inputs = np.column_stack((xs,zs))
noise = np.random.uniform(-1, 1, (observations,1))
generated_targets = 2*xs - 3*zs + 5 + noise
np.savez('TFSimpleLinear', inputs=generated_inputs, targets=generated_targets)
Tahap berikutnya adalah menjabarkan model. Pada tahap ini kita baru membuat objek TensorFlow, model belum dieksekusi.
Placeholder, TensorFlow memiliki objek khusus untuk menyimpan data input dan target, yaitu placeholder. Untuk dokumentasi detail silakan click disini.
Input dan targets akan diinisialisasi dengan perintah tf.placeholder, hal yang perlu diperhatikan adalah dimensi matrix yang akan digunakan.
- Dimensi input adalah jumlah observasi x ukuran input, ukuran input adalah matrix n x 2. Pada inisialisasi dituliskan none, bukan berarti ukuran observasi adalah tidak ada, tetapi tensorflow akan mendeteksi secara otomatis jumlah observasi.
- Dimensi output adalah jumlah observasi x ukuran output, ukuran output adalah matrix n x 1. Sama seperti input, none menunjukan ukuran observasi akan ditentukan oleh tensorflow.
tf.float32 adalah type variable pada TensorFlow, karena data input dan target adalah continues number, maka digunakan float32.
Variables, object TensorFlow untuk menyimpan data weight dan bias (variable yang akan dihitung oleh model). Dalam proses iterasi model learning, Object tf.Variable ini akan mempertahankan data didalamnya, sedangkan placeholder data didalamnya akan dibuang.
Berikutnya adalah mendefinisikan weights dan biases awal secara random dengan range [-0.1, 0.1] menggunakan perintah tf.random_uniform. Perhatikan dimensi weights adalah matrix 2 x 1 dan weigth adalah matrix 1 x 1.
Perhatian, pada tahap ini, weight dan bias baru didefinisikan secara objek, nilai awal belum diinisialisasi.
Setelah itu tentukan fungsi output dengan menggunakan perintah matmul. Seperti yang sudah kita pelajari, model linear adalah y = wx + b.
Perhatian, sampai pada tahap ini model belum dieksekusi untuk melakukan pembelajaran. Tahap ini baru menjabarkan variable dan placeholder yang akan digunakan oleh TensorFlow untuk model learning.
#penjabaran model input_size = 2 output_size = 1 inputs = tf.placeholder(tf.float32, [None, input_size]) targets = tf.placeholder(tf.float32, [None, output_size]) weights = tf.Variable(tf.random_uniform([input_size, output_size], minval=-0.1, maxval=0.1)) biases = tf.Variable(tf.random_uniform([output_size], minval=-0.1, maxval=0.1)) outputs = tf.matmul(inputs, weights) + biases
Tahap berikutnya adalah menentukan objective function dan optimization method.
Sama seperti linear regression pada course sebelumnya dimana objective function adalah loss function L2-norm/2, ini akan kita gunakan disini.
TensorFlow memiliki module losses dengan metoda mean_squared_error yang sama dengan L2-norm.
Argument fungsi mean_squared_error adalah labels dan predictions. Dimana labels adalah nilai yang benar atau variable targets yang kita generate diatas dan predictions adalah hasil perhitungan outputs.
Untuk optimization method, sengaja digunakan GradientDescentOptimizer, sama seperti pada course sebelumnya.
tf.train.GradientDescentOptimizer memerlukan input Learning rate yang kita set dengan nilai 0.05, dan yang akan diminimize adalah loss dalam hal ini mean_loss yang telah kita tentukan pada baris sebelumnya.
mean_loss = tf.losses.mean_squared_error(labels=targets, predictions=outputs) / 2. optimize = tf.train.GradientDescentOptimizer(learning_rate=0.05).minimize(mean_loss)
Tahap berikutnya adalah inisialisasi session. Pada TensorFlow, model training akan dilakukan dalam session.
sess = tf.InteractiveSession()
Setelah session, berikutnya inisialisasi variable weights dan biases. Perintah tf.global_variables_initializer() akan meminta TensorFlow untuk mempersiapkan global variables yang akan diinit, dalam hal ini adalah weights dan biases yang sudah dideklarasikan menggunakan object tf.Variables (lihat code diatas).
Gunakan perintah sess.run untuk meminta Tensor mengeksekusi variable inisialisasi.
initializer = tf.global_variables_initializer() sess.run(initializer)
Berikutnya adalah load data training yang telah kita buat pada awal code.
training_data = np.load('TFSimpleLinear.npz')
Akhirnya kita sampai pada model training. Kita akan gunakan 100 iterasi (sama seperti pada course sebelumnya).
e pada for loop adalah term epoch, atau iterasi full dataset pada machine learning, untuk selanjutnya term ini akan digunakan.
Dalam for loop, kita akan hitung loss function. Perhatikan, untuk menjalankan perintah dalam TensorFlow harus dilakukan dalam sess.run().
Kita akan menjalankan optimize dan mean_loss yang sudah kita deklarasikan sebelumnya. Data yang akan diinput akan didefinisikan dalam feed_dict, dimana inputs akan diisi dengan training_data[‘inputs’] dan targets: diisi dengan training_data[‘targets’].
Perhatikan, training_data berisi data yang kita load pada baris code sebelumnya. Dimana isinya adalah data yang digenerate otomatis pada awal program diatas.
Hasil dari optimize akan selalu none dan kita tidak membutuhkannya, oleh karena itu disimpan dalam dummy variable (_) , sementara hasil perhitungan mean_loss akan disimpan dalam curr_loss (silakan lihat konsep dummy variable pada lesson Python String Lanjutan)
for e in range(100):
_, curr_loss = sess.run([optimize, mean_loss],
feed_dict={inputs: training_data['inputs'], targets: training_data['targets']})
print(curr_loss)