Implementasi Loss Function pada Regresi Linier

Loss function sangat penting untuk algoritma machine learning. Mereka mengukur jarak antara output model dan nilai target (kebenaran). Dalam post ini, kami menampilkan berbagai implementasi loss function di TensorFlow.

Untuk mengoptimalkan algoritma machine learning kita, kita perlu mengevaluasi hasilnya. Mengevaluasi hasil di TensorFlow tergantung pada menentukan loss function. Loss function memberi tahu TensorFlow seberapa baik atau buruk prediksi dibandingkan dengan hasil yang diinginkan. Dalam banyak kasus, kita akan memiliki serangkaian data dan target untuk melatih algoritma kita. Loss function membandingkan target dengan prediksi dan memberikan jarak numerik antara keduanya. Untuk post ini, kita akan membahas loss function utama yang dapat kita terapkan di TensorFlow. Untuk melihat bagaimana loss function yang berbeda beroperasi, kita akan membahasnya pada post kali ini. Kita pertama-tama akan memulai sebuah grafik komputasi dan load matplotlib, library ploting python, sebagai berikut:

	import matplotlib.pyplot as plt
	import tensorflow as tf
	sess = tf.Session()

view raw 1 hosted with ❤ by GitHub

Pertama kita akan berbicara tentang loss function untuk regresi, yaitu memprediksi variabel dependen kontinu. Untuk memulai, kita akan membuat urutan prediksi dan target sebagai tensor. Kita akan membuat 500 x-value antara -1 dan 1. Gunakan kode berikut:

	x_vals = tf.linspace(-1., 1., 500)
	target = tf.constant(0.)

view raw 2 implementing loss function hosted with ❤ by GitHub

1. L2_norm loss juga dikenal sebagai Euclidean loss function, Itu hanya kuadrat jarak ke target. Di sini kita akan menghitung loss function seolah-olah targetnya nol. Sebagai berikut:

	l2_y_vals = tf.square(target - x_vals)
	l2_y_out = sess.run(l2_y_vals)

view raw 3 implementing loss function hosted with ❤ by GitHub

 TensorFlow memiliki bentuk bawaan dari L2_norm, yang disebut nn.l2_loss (). Fungsi ini sebenarnya setengah dari L2_norm di atas. . Dengan kata lain, itu sama seperti sebelumnya tetapi dibagi 2.

2. L1_norm loss juga dikenal sebagai loss function absolut. Daripada mengkuadratkan perbedaan(selisih), kita mengambil nilai absolut. L1_norm lebih baik untuk outlier daripada L2_norm karena tidak terlalu curam untuk nilai yang lebih besar. Satu hal yang harus diperhatikan adalah bahwa L1_norm tidak smooth pada target dan ini dapat mengakibatkan algoritma tidak konvergen dengan baik. sebagai berikut:

	l1_y_vals = tf.abs(target - x_vals)
	l1_y_out = sess.run(l1_y_vals)

view raw 4 implementing loss function hosted with ❤ by GitHub

3. Pseudo-Huber loss adalah pendekatan continuous and smooth untuk Huber loss function. Loss function ini mencoba mengambil yang terbaik dari L1 dan L2_norm dengan menjadi cembung di dekat target dan kurang curam untuk nilai ekstrim. Bentuknya tergantung pada parameter ekstra, delta, yang menentukan seberapa curamnya. Kami akan merencanakan dua bentuk, delta1 = 0,25 dan delta2 = 5 untuk menunjukkan perbedaannya, sebagai berikut:

	delta1 = tf.constant(0.25)
	phuber1_y_vals = tf.multiply(tf.square(delta1), tf.sqrt(1. + tf.square((target - x_vals)/delta1))- 1.)
	phuber1_y_out = sess.run(phuber1_y_vals)
	delta2 = tf.constant(5.)
	phuber2_y_vals = tf.multiply(tf.square(delta2), tf.sqrt(1. +
	tf.square((target - x_vals)/delta2))- 1.)
	phuber2_y_out = sess.run(phuber2_y_vals)

view raw 5 implementing loss function hosted with ❤ by GitHub

4. Klasifikasi Loss function digunakan untuk mengevaluasi loss ketika memprediksi hasil kategoris.

5. Kita perlu mendefinisikan kembali prediksi  (x_vals) dan target. Kita akan menyimpan hasilnya dan memplotnya di bagian selanjutnya. Gunakan yang berikut:

	x_vals = tf.linspace(-3., 5., 500)
	target = tf.constant(1.)
	targets = tf.fill([500,], 1.)

view raw 6 implementing loss function hosted with ❤ by GitHub

6. Hinge loss kebanyakan digunakan untuk mendukung mesin vektor, tetapi dapat digunakan dalam jaringan saraf juga. Ini dimaksudkan untuk menghitung loss diantara dua kelas target, 1 dan -1. Dalam kode berikut, kami menggunakan nilai target 1, sehingga semakin dekat prediksi kami semakin mendekati 1, semakin rendah nilai loss:

	hinge_y_vals = tf.maximum(0., 1. - tf.multiply(target, x_vals))
	hinge_y_out = sess.run(hinge_y_vals)

view raw 7 implementing loss function hosted with ❤ by GitHub

7. Cross-entropy loss untuk kasus biner kadang-kadang juga disebut sebagai loss function logistik. Ini terjadi ketika kita memprediksi dua kelas 0 atau 1. Kita ingin mengukur jarak dari kelas yang sebenarnya (0 atau 1) ke nilai prediksi, yang biasanya merupakan bilangan real antara 0 dan 1. Untuk mengukur jarak ini, kita dapat menggunakan formula cross entropy dari teori informasi, sebagai berikut:

	xentropy_y_vals = - tf.multiply(target, tf.log(x_vals)) - tf.multiply((1. - target), tf.log(1. - x_vals))
	xentropy_y_out = sess.run(xentropy_y_vals)

view raw 8 implementing loss function hosted with ❤ by GitHub

8. Sigmoid_cross_entropy_loss sangat mirip dengan loss function sebelumnya, kecuali kita mengubah x-value dengan fungsi sigmoid sebelum kita menempatkannya pada Cross-entropy loss, sebagai berikut:

	xentropy_sigmoid_y_vals = tf.nn.sigmoid_cross_entropy_with_logits(logits=x_vals, labels=targets)
	xentropy_sigmoid_y_out = sess.run(xentropy_sigmoid_y_vals)

view raw 9 implementing loss function hosted with ❤ by GitHub

9. Weighted cross entropy loss adalah versi berbobot dari Sigmoid_cross_entropy_loss. Kami memberikan bobot pada target positif. Sebagai contoh, kita akan menimbang target positif sebesar 0,5, sebagai berikut:

	weight = tf.constant(0.5)
	xentropy_weighted_y_vals = tf.nn.weighted_cross_entropy_with_logits(x_vals, targets, weight)
	xentropy_weighted_y_out = sess.run(xentropy_weighted_y_vals)

view raw 10 implementing loss function hosted with ❤ by GitHub

10. Softmax cross-entropy loss beroperasi pada output yang tidak normal. Fungsi ini digunakan untuk mengukur loss ketika hanya ada satu kategori target, bukan beberapa. Karena ini, fungsi mengubah output menjadi distribusi probabilitas melalui fungsi softmax dan kemudian menghitung loss function dari distribusi probabilitas yang sebenarnya, sebagai berikut:

	unscaled_logits = tf.constant([[1., -3., 10.]])
	target_dist = tf.constant([[0.1, 0.02, 0.88]])
	softmax_xentropy = tf.nn.softmax_cross_entropy_with_logits(logits=unscaled_logits, labels=target_dist)
	print(sess.run(softmax_xentropy))
	#[1.1601256]

view raw 11 implementing loss function hosted with ❤ by GitHub

11. Sparse softmax cross-entropy loss sama seperti sebelumnya, kecuali sebagai target adalah distribusi probabilitas, ini adalah indeks kategori mana yang benar. Sebagai berikut :

	unscaled_logits = tf.constant([[1., -3., 10.]])
	sparse_target_dist = tf.constant([2])
	sparse_xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=unscaled_logits, labels=sparse_target_dist)
	print(sess.run(sparse_xentropy))
	#[0.00012564]

view raw 12 implementing loss function hosted with ❤ by GitHub

Disini sekarang bagaimana menggunakan matplotlib untuk membuat plot regresi loss function

	x_array = sess.run(x_vals)
	plt.plot(x_array, l2_y_out, 'b-', label='L2 Loss')
	plt.plot(x_array, l1_y_out, 'r--', label='L1 Loss')
	plt.plot(x_array, phuber1_y_out, 'k-.', label='P-Huber Loss (0.25)')
	plt.plot(x_array, phuber2_y_out, 'g:', label='P-Huber Loss (5.0)')
	plt.ylim(-0.2, 0.4)
	plt.legend(loc='lower right', prop={'size': 11})
	plt.show()

view raw 13 implementing loss function hosted with ❤ by GitHub

Kemudian disini bagaimana menggunakan matplotlib untuk membuat plot variasi klasifikasi loss function

	x_array = sess.run(x_vals)
	plt.plot(x_array, hinge_y_out, 'b-', label='Hinge Loss')
	plt.plot(x_array, xentropy_y_out, 'r--', label='Cross Entropy Loss')
	plt.plot(x_array, xentropy_sigmoid_y_out, 'k-.', label='Cross Entropy Sigmoid Loss')
	plt.plot(x_array, xentropy_weighted_y_out, 'g:', label='Weighted Cross Enropy Loss (x0.5)')
	plt.ylim(-1.5, 3)
	plt.legend(loc='lower right', prop={'size': 11})
	plt.show()

view raw 14 implementing loss function hosted with ❤ by GitHub

Loss Function	Use	Benefit	Disadvantages
L2	Regresi	Lebih stabil	Kurang kuat
L1	Regresi	lebih kuat	Kurang stabil
Psuedo-Huber	Regresi	lebih kuat dan stabil	One more parameter
Hinge	Klasifikasi	Menciptakan margin maximal untuk menggunakan SVM	Unbounded loss affected by outliers
Cross-entropy	Klasifikasi	Lebih Stabil	Unbounded loss, less robust

Yang tersisa dari semua klasifikasi loss function harus dilakukan dengan jenis cross-entropy loss. Cross-entropy sigmoid Loss function digunakan pada unscaled logits dan lebih disukai daripada komputasi sigmoid, dan kemudian cross entropy, karena TensorFlow memiliki cara yang lebih baik untuk menangani kasus-kasus numerical edge. Hal yang sama berlaku untuk softmax cross entropy dan sparse softmax cross entropy.

Sebagian besar klasifikasi loss function yang dijelaskan di sini adalah untuk dua prediksi kelas. Ini dapat diperluas ke beberapa kelas melalui penjumlahan istilah cross entropy atas setiap prediksi / target.

You can download all code in MYGITHUB Thank you