Modul 6 Sains Data: Neural Network dengan Tensorflow dan Keras

Pengantar Neural Network dengan TensorFlow dan Keras”

Offline di Departemen Matematika

Published

April 28, 2025

Sekarang kita sudah masuk ke materi artificial neural network (ANN) atau biasa disebut neural network (NN), yang mendasari dunia deep learning.

Saat modul praktikum ini disusun (April 2024), ada dua framework utama untuk deep learning di Python, yaitu:

TensorFlow: https://www.tensorflow.org/

(dan Keras di dalamnya: https://keras.io/)
PyTorch: https://pytorch.org/

Kedua framework ini bersaing. Umumnya, TensorFlow lebih sering digunakan di industri, sedangkan PyTorch lebih sering digunakan dalam riset/penelitian.

Di pertemuan kali ini, kita akan membahas TensorFlow, baik penggunaannya secara sendiri (pure TensorFlow, yaitu tanpa Keras) maupun dengan bantuan Keras. Kalau belum punya, instal terlebih dahulu:

pip install tensorflow

Keras terinstal bersama TensorFlow (karena Keras ada di dalamnya).

Lalu import:

import tensorflow as tf
from tensorflow import keras
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

tfversion = tf.__version__
print(tfversion)

2.18.0

kerasversion = keras.__version__
print(kerasversion)

3.8.0

Teori Neural Network

Overview:

Secara umum, suatu neural network terdiri dari sejumlah layer atau lapisan (minimal dua).
Layer pertama disebut input layer, dan layer terakhir disebut output layer.
Tiap layer terdiri dari sejumlah neuron, yang masing-masing bisa menyimpan suatu nilai.
Kecuali input layer, tiap neuron terhubung dengan sejumlah neuron di layer sebelumnya.
Tiap sambungan terdiri dari nilai weight (sebagai pengali), nilai bias (sebagai pergeseran), dan suatu “fungsi aktivasi” yang menghasilkan nilai untuk neuron tujuan.
Weight maupun bias disebut parameter dari neural network.
Proses training adalah terus-menerus memperbarui parameter hingga hasil prediksi neural network sudah cukup baik, dengan meminimumkan suatu loss function atau fungsi objektif (yang intinya menghitung error).
Suatu neural network bisa memiliki sejumlah layer, masing-masing dengan banyaknya neuron tertentu dan fungsi-fungsi aktivasi tertentu. Hal-hal itu disebut hyperparameter dari neural network. Suatu arsitektur adalah suatu pilihan/konfigurasi hyperparameter.

SLP: (Single-Layer) Perceptron

ANN paling pertama adalah perceptron (juga disebut SLP atau single-layer perceptron) yang dirancang oleh Frank Rosenblatt pada tahun 1957 (Géron, 2019). Ini adalah neural network yang paling sederhana, bahkan ini bisa disebut building block dari semua ANN (apabila diberi kebebasan untuk modifikasi). Konsep dasar neural network bisa kita pelajari di sini.

Sumber gambar: Aggarwal (2018) hal. 5

Perceptron hanya terdiri dari satu input layer dan satu output layer. Bahkan, aslinya hanya ada satu neuron di output layer.

Apabila dibutuhkan lebih dari satu neuron di output layer, itu bisa dianggap menggunakan lebih dari satu perceptron (yaitu menggunakan banyaknya perceptron sesuai banyaknya neuron di output layer), yang saling “ditumpuk”:

Sumber gambar: Goodfellow, et. al. (2016) hal. 337

Perhatikan bahwa, tiap neuron di layer asal terhubung dengan tiap neuron di layer tujuan. Layer tujuan seperti ini disebut dense (padat). Kebalikan dari dense adalah sparse.

Aslinya, fungsi aktivasi yang digunakan oleh perceptron adalah Heaviside step function \(H(v)\) yang mungkin kalian kenal dari mata kuliah PDB, atau juga disebut threshold activation function:

\[H(v) = \begin{cases} 1, & v \ge 0 \\ 0, & v < 0 \end{cases}\]

Sehingga, untuk output neuron ke-\(j\) yang disambung dari \(n\) input neuron, model perceptron bisa dirumuskan sebagai berikut:

\[y_j = H\left(\left(\sum_{i=1}^{n} w_{ij} x_i \right) + b_j\right)\]

dengan

\(x_i\) adalah nilai pada input neuron ke-\(i\)
\(y_j\) adalah nilai pada output neuron ke-\(j\)
\(w_{ij}\) adalah parameter weight untuk sambungan input neuron ke-\(i\) menuju output neuron ke-\(j\)
\(b_j\) adalah parameter bias untuk output neuron ke-\(j\)

Lebih umumnya,

\[y_j = \Phi\left(\left(\sum_{i=1}^{n} w_{ij} x_i \right) + b_j\right)\]

dengan \(\Phi(v)\) adalah sembarang fungsi aktivasi.

Note: seperti di gambar, sebenarnya bias juga bisa dianggap neuron istimewa yang nilai \(x_i\) nya selalu satu.

Biasanya, semua nilai di layer selanjutnya dihitung secara sekaligus menggunakan perkalian matriks, dengan perumusan:

\[\textbf{y} = \Phi\left(W^T \textbf{x} + \textbf{b}\right)\]

dengan \(\textbf{x} = [x_i]\), \(\textbf{y} = [y_j]\), dan \(\textbf{b} = [b_j]\) adalah vektor kolom, serta \(W = \left[w_{ij}\right]\) adalah matriks.

Itu untuk satu buah data training.

Bisa saja, beberapa data training diperhitungkan sekaligus. Caranya, vektor kolom \(\textbf{x}\) itu kita “lebarkan” ke samping sehingga menjadi matriks \(X = [x_{it}]\), sehingga data training ke-\(t\) ada di kolom ke-\(t\). Dengan demikian, output nya akan berupa matriks \(Y = [y_{jt}]\) dengan hasil untuk data training ke-\(t\) ada di kolom ke-\(t\). Selain itu, vektor \(\textbf{b}\) perlu diperluas menjadi matriks \(B\) dengan tiap kolom identik, dan fungsi aktivasi \(\Phi\) dihitung per kolom.

\[Y = \Phi\left(W^T X + B\right)\]

Kembali ke kasus satu buah data training. Biasanya, dataset disajikan dengan tiap fitur di kolom sendiri, tidak seperti perumusan kita sejauh ini dengan tiap fitur di baris tersendiri. Untuk menyesuaikan, kita bisa men-transpose semuanya:

\[\textbf{y} = \Phi\left(\textbf{x} W + \textbf{b}\right)\]

dengan \(\textbf{x} = [x_i]\), \(\textbf{y} = [y_j]\), dan \(\textbf{b} = [b_j]\) adalah vektor baris, serta \(W = \left[w_{ji}\right]\) adalah matriks berisi bobot untuk menyambung ke output neuron ke-\(j\) dari input neuron ke-\(i\).

MLP: Multilayer Perceptron

Konsep single-layer perceptron bisa diperumum menjadi multilayer perceptron atau neural network yang biasa kita kenal, dengan menambahkan beberapa layer di antara input layer dan output layer. Semua layer selain input layer dan output layer disebut hidden layer.

Sumber gambar: Aggarwal (2018) hal. 18

Konsep perhitungan antara tiap layer tetap sama, yaitu

\[\textbf{y} = \Phi\left(\textbf{w}^T \textbf{x} + \textbf{b}\right)\]

(versi vektor kolom), atau

\[\textbf{y} = \Phi\left(\textbf{x} W + \textbf{b}\right)\]

(versi vektor baris)

Fungsi Aktivasi

Sumber gambar: Aggarwal (2018) hal. 13

Beberapa fungsi aktivasi adalah (Aggarwal, 2018, hal. 12-13):

“Linier” atau identitas

\[\Phi(v) = v\]

Sign (fungsi tanda): \(\text{sign}(v)\) atau \(\text{sgn}(v)\)

\[ \Phi(v) = \text{sign}(v) = \begin{cases} 1, & v > 0 \\ 0, & v = 0 \\ -1, & v < 0 \end{cases} \]

Sigmoid, terkadang dilambangkan \(\sigma(v)\) dan terkadang disebut fungsi aktivasi logistik

\[\Phi(v) = \frac{1}{1 + e^{-v}}\]

(Soft) tanh: \(\tanh(v)\)

\[\Phi(v) = \frac{e^{2v} - 1}{e^{2v} + 1} = 2 * \text{sigmoid}(2v) - 1\]

Rectified Linear Unit (ReLU)

\[\Phi(v) = \max\{v, 0\}\]

Hard tanh

\[\Phi(v) = \max\{\min\{v, 1\}, -1\}\]

Fungsi aktivasi yang paling sering digunakan adalah ReLU, kecuali untuk output layer.

Untuk output layer, biasanya,

untuk regresi, banyaknya neuron sesuai banyaknya nilai prediksi (umumnya hanya satu), dan digunakan fungsi aktivasi linier
untuk klasifikasi multiclass (lebih dari dua kelas), biasanya banyaknya output neuron sesuai banyaknya kelas, dan digunakan fungsi aktivasi softmax sebagai berikut, agar output berupa peluang tiap kelas:

\[\Phi(\overline{v})_i = \frac{\exp(v_i)}{\sum_{j=1}^k \exp(v_j)}\]

untuk klasifikasi biner, hanya ada satu neuron di output layer, dan digunakan fungsi aktivasi sigmoid. (Keberadaan hanya satu output neuron lebih hemat daripada menggunakan dua output neuron)

Loss function

Misalkan \(y_i\) adalah nilai sebenarnya dan \(\hat{y}_i\) adalah hasil prediksi.

Untuk regresi, biasa digunakan MSE (mean squared error), juga disebut L2 loss:

\[\text{MSE}(y, \hat{y}) = \frac{1}{n} \sum_{i=1}^{n} \left( y_i - \hat{y}_i \right)^2\]

Untuk klasifikasi, biasa digunakan yang namanya cross-entropy loss, juga disebut logistic loss atau log loss:

\[L_{\text{log}}(y,\hat{y}) = -(y \ln (\hat{y}) + (1 - y) \ln (1 - \hat{y}))\]

Proses training

Proses training untuk neural network dilakukan secara iteratif, yaitu tiap iterasi akan memperbarui parameter sehingga nilai loss function menjadi lebih kecil.

Tiap iterasi melakukan langkah-langkah berikut untuk tiap data training:

Forward pass: menghitung nilai output akhir, yaitu \(\hat{y}\) (hasil prediksi), berdasarkan input data training.
Menghitung loss antara \(y\) (nilai asli) dan \(\hat{y}\)
Backpropagation: menghitung gradien dari loss terhadap tiap parameter, secara “mundur”
Update optimizer: menggunakan algoritma optimizer seperti gradient descent untuk memperbarui parameter-parameter (weights and biases) berdasarkan gradien dari loss

Note: ada banyak optimizer, seperti gradient descent, SGD (stochastic gradient descent), dan Adam (adaptive moment estimation). Pilihan optimizer (serta parameter-parameter yang bisa diatur untuk optimizer, seperti learning rate) juga menjadi hyperparameter untuk neural network.

Note: istilah backward pass meliputi langkah backpropagation dan update optimizer.

Apabila data training sangat banyak, terkadang data training tersebut dibagi menjadi beberapa batch, dan tiap iterasi menggunakan batch yang berbeda. Apabila semua batch sudah diproses, sebutannya adalah satu epoch. Sehingga, satu epoch terdiri dari sejumlah iterasi sesuai banyaknya batch.

(Apabila data training tidak dibagi menjadi batch, maka satu epoch sama dengan satu iterasi.)

Contoh optimizer: metode gradient descent

Metode gradient descent mencari minimum lokal dari suatu fungsi \(g\) (dalam hal ini, loss function) dengan rumus iterasi seperti berikut:

\[\textbf{x}_{i+1} = \textbf{x}_i - \eta \nabla g\left(\textbf{x}_i\right)\]

dengan \(\eta\) adalah learning rate. Simbol nabla (\(\nabla\)) menandakan perhitungan gradien.

Perhatikan bahwa gradien menandakan arah tercepat untuk kenaikan fungsi, seringkali disebut direction of steepest ascent. Di sini, justru kita mengurangi; atau sama saja, menambah dengan kebalikannya, yaitu arah tercepat untuk penurunan fungsi. Sedangkan, learning rate melambangkan seberapa jauh kita melangkah ke arah penurunan tersebut. Harapannya, kita akan cepat konvergen menuju minimum fungsi, karena kita terus melangkah ke arah penurunan tercepat.

Variasi gradient descent adalah SGD (stochastic gradient descent). Bedanya sederhana saja:

Gradient descent selalu memanfaatkan keseluruhan data training yang diberikan (lebih tepatnya, keseluruhan batch) di tiap iterasi.
Sedangkan, SGD selalu memilih sebagian data training saja (lebih tepatnya, sebagian dari batch), dan cara memilihnya bersifat random atau disebut stokastik.

Keuntungan SGD dibandingkan gradient descent biasa:

Waktu training menjadi lebih cepat
Tidak rawan terjebak di minimum lokal: https://www.youtube.com/watch?v=UmathvAKj80&t=102

Train-Validation-Test Split

Ketika menggunakan metode machine learning yang di-training secara iteratif, seperti neural network, biasanya ada juga yang namanya validation data. Sehingga, di awal, dataset dipisah menjadi data train, data validation, dan data test.

Gunanya, kita bisa menguji akurasi model di akhir tiap epoch, menggunakan data validation daripada data test.

Rasio yang paling sering digunakan adalah 80-10-10, yaitu 80% data train, 10% data validation, dan 10% data test.

Apabila menggunakan scikit-learn, untuk melakukan train-validation-test split, caranya adalah dengan split dua kali, yaitu

Split menjadi data “train” dan data test
Data “train” itu di-split lagi menjadi data train sesungguhnya dan data validation

atau bisa juga

Split menjadi data train dan data “test”
Data “test” itu di-split lagi menjadi data validation dan data test sesungguhnya

Mengenal TensorFlow

import tensorflow as tf

Tensor, Konstanta

Tensor adalah semacam perumuman dari array/vektor ataupun matriks.

Skalar (bilangan) adalah tensor berdimensi nol (atau rank nol).
Array atau vektor adalah tensor berdimensi satu (atau rank satu).
Matriks adalah tensor berdimensi dua (atau rank dua).
Istilah “tensor” biasanya merujuk pada tensor berdimensi tiga (atau rank tiga), yaitu semacam matriks tapi tiga dimensi, sehingga ada baris, kolom, dan satu dimensi lagi.

Fitur tensor di TensorFlow mirip dengan fitur array di numpy, yang memang juga bisa multidimensi.

x = tf.zeros(shape = (3,4))
print(x)

tf.Tensor(
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]], shape=(3, 4), dtype=float32)

x = tf.ones(shape = (3,4))
print(x)

tf.Tensor(
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]], shape=(3, 4), dtype=float32)

Untuk menentukan array kita sendiri, di numpy digunakan numpy.array.

Untuk menentukan tensor kita sendiri, di TensorFlow digunakan tensorflow.constant (agar nilainya tidak bisa diubah) atau tensorflow.Variable (nilainya bisa diubah).

Pada umumnya (apabila tidak ada keterangan), tensor di TensorFlow berupa tensorflow.constant

const0 = tf.constant(1.5)
print(const0)

tf.Tensor(1.5, shape=(), dtype=float32)

print(tf.rank(const0))

tf.Tensor(0, shape=(), dtype=int32)

const1 = tf.constant([2.31, 4.567, 8.9])
print(const1)

tf.Tensor([2.31  4.567 8.9  ], shape=(3,), dtype=float32)

print(tf.rank(const1))

tf.Tensor(1, shape=(), dtype=int32)

const1[0] = 52.5

TypeError: 'tensorflow.python.framework.ops.EagerTensor' object does not support item assignment

const2 = tf.constant([
    [1, 2.718, 3.14],
    [4, 5, 6.28]
])
print(const2)

tf.Tensor(
[[1.    2.718 3.14 ]
 [4.    5.    6.28 ]], shape=(2, 3), dtype=float32)

print(tf.rank(const2))

tf.Tensor(2, shape=(), dtype=int32)

Variabel dan assignment untuk tensor

v = tf.Variable(initial_value = tf.zeros(shape = (2,3)))
print(v)

<tf.Variable 'Variable:0' shape=(2, 3) dtype=float32, numpy=
array([[0., 0., 0.],
       [0., 0., 0.]], dtype=float32)>

Assignment untuk variabel di TensorFlow dilakukan dengan .assign

v.assign(tf.ones(shape = (2,3)))
print(v)

<tf.Variable 'Variable:0' shape=(2, 3) dtype=float32, numpy=
array([[1., 1., 1.],
       [1., 1., 1.]], dtype=float32)>

v[0, 0].assign(9)
print(v)

<tf.Variable 'Variable:0' shape=(2, 3) dtype=float32, numpy=
array([[9., 1., 1.],
       [1., 1., 1.]], dtype=float32)>

Ada juga .assign_add, sama saja dengan +=

v.assign_add(tf.ones(shape = (2,3)))
print(v)

<tf.Variable 'Variable:0' shape=(2, 3) dtype=float32, numpy=
array([[10.,  2.,  2.],
       [ 2.,  2.,  2.]], dtype=float32)>

Serupa, ada .assign_sub yaitu -=

v.assign_sub(tf.ones(shape = (2,3)))
print(v)

<tf.Variable 'Variable:0' shape=(2, 3) dtype=float32, numpy=
array([[9., 1., 1.],
       [1., 1., 1.]], dtype=float32)>

Tensor random

Kita bisa membuat tensor dengan nilai yang random, misalnya dari distribusi normal atau dari distribusi uniform

# dari distribusi normal
x = tf.random.normal(shape = (2,3), mean = 0, stddev = 1)
print(x)

tf.Tensor(
[[ 0.1701715  -1.5403947   0.5286183 ]
 [-0.6036802   0.27208146 -1.4331723 ]], shape=(2, 3), dtype=float32)

# dari distribusi uniform
x = tf.random.uniform(shape = (2,3), minval = 0, maxval = 1)
print(x)

tf.Tensor(
[[0.81854975 0.95575297 0.9605453 ]
 [0.36875296 0.45838344 0.62123   ]], shape=(2, 3), dtype=float32)

Operasi TensorFlow seperti numpy

Operasi di TensorFlow mirip dengan numpy

a = 4 * tf.ones((2, 2))
print(a)

tf.Tensor(
[[4. 4.]
 [4. 4.]], shape=(2, 2), dtype=float32)

b = tf.square(a)
print(b)

tf.Tensor(
[[16. 16.]
 [16. 16.]], shape=(2, 2), dtype=float32)

c = tf.sqrt(a)
print(c)

tf.Tensor(
[[2. 2.]
 [2. 2.]], shape=(2, 2), dtype=float32)

d = b + c
print(d)

tf.Tensor(
[[18. 18.]
 [18. 18.]], shape=(2, 2), dtype=float32)

# perkalian matriks
e = tf.matmul(a, c)
print(e)

tf.Tensor(
[[16. 16.]
 [16. 16.]], shape=(2, 2), dtype=float32)

# perkalian per elemen
e *= d
print(e)

tf.Tensor(
[[288. 288.]
 [288. 288.]], shape=(2, 2), dtype=float32)

Automatic differentiation dengan `GradientTape`

TensorFlow memiliki fitur yang bernama automatic differentiation, juga disebut autodiff atau autograd. Dengan fitur ini, TensorFlow bisa menghitung turunan/gradien secara otomatis. Fitur ini membedakan antara TensorFlow dengan numpy.

Caranya adalah menggunakan GradientTape seperti berikut. Semua operasi di dalam with statement dicatat oleh GradientTape, yang kemudian bisa menghitung gradiennya.

Contohnya, turunan \(x^3\) terhadap \(x\) di \(x=4\) adalah \(3(4)^2 = 48\).

x = tf.Variable(4.0)
with tf.GradientTape() as tape:
    y = x ** 3
dy_dx = tape.gradient(y, x)
print(dy_dx)

tf.Tensor(48.0, shape=(), dtype=float32)

Tidak harus dengan tensorflow.Variable, bahkan dengan tensorflow.constant juga bisa. Namun, kita harus secara eksplisit meminta TensorFlow untuk memperhatikan nilai x, yaitu dengan .watch

x = tf.constant(4.0)
with tf.GradientTape() as tape:
    tape.watch(x)
    y = x ** 3
dy_dx = tape.gradient(y, x)
print(dy_dx)

tf.Tensor(48.0, shape=(), dtype=float32)

Kita bisa menghitung turunan kedua dengan nested with statement seperti berikut, contohnya turunan kedua dari \(x^3\) terhadap \(x\) di \(x=4\) adalah \(6(4) = 24\)

x = tf.Variable(4.0)
with tf.GradientTape() as tape2:
    with tf.GradientTape() as tape1:
        y = x ** 3
    dy_dx = tape1.gradient(y, x)
dy2_dx2 = tape2.gradient(dy_dx, x)
print(dy2_dx2)

tf.Tensor(24.0, shape=(), dtype=float32)

(Pure) TensorFlow: klasifikasi biner dengan perceptron

Perceptron digunakan untuk klasifikasi biner. Mari kita coba buat model perceptron dengan pure TensorFlow, menggunakannya untuk memprediksi kelas dari titik-titik dua dimensi.

Generate dataset

Dataset titik-titik dua dimensi, dengan dua kelas (misalnya “negatif” dan “positif”), bisa kita generate:

num_samples_per_class, num_classes = 1000, 2
negative_samples = np.random.multivariate_normal(mean = [0,3], cov = [[1,0.5],[0.5,1]], size = num_samples_per_class)
positive_samples = np.random.multivariate_normal(mean = [3,0], cov = [[1,0.5],[0.5,1]], size = num_samples_per_class)

inputs = np.vstack((negative_samples, positive_samples)).astype(np.float32)
targets = np.vstack((
    np.zeros((num_samples_per_class, 1), dtype = 'float32'),
    np.ones((num_samples_per_class, 1), dtype = 'float32')
))

print(inputs.shape)
print(targets.shape)

(2000, 2)
(2000, 1)

plt.scatter(inputs[:, 0], inputs[:, 1], c=targets[:, 0])
plt.show()

Kalau mau, kita bisa susun data ini ke dalam bentuk pandas DataFrame, lalu export ke CSV:

titik_negatif_positif_df = pd.DataFrame(
    np.hstack([inputs, targets]),
    columns = ["x", "y", "kelas"]
)

titik_negatif_positif_df

	x	y	kelas
0	-0.109873	2.904561	0.0
1	-0.070282	3.484931	0.0
2	-0.556087	3.335495	0.0
3	-0.314094	3.379053	0.0
4	-0.636380	2.201054	0.0
...	...	...	...
1995	3.338591	0.450919	1.0
1996	3.168565	0.507815	1.0
1997	1.506407	-0.884150	1.0
1998	1.901459	-0.520556	1.0
1999	1.771375	-0.421099	1.0

2000 rows × 3 columns

titik_negatif_positif_df.to_csv("./titik_negatif_positif.csv", index=False)

Import kembali dataset

Tentunya, karena titik-titiknya di-generate secara random, mungkin saja titik-titik yang kalian peroleh akan sedikit berbeda, bahkan tiap kali di-run ulang akan berbeda.

Kalau kalian mau menyamakan dengan modul ini, CSV nya bisa di-download dari GitHub Pages ini: titik_negatif_positif.csv

Kita bisa import kembali:

df = pd.read_csv("./titik_negatif_positif.csv", dtype="float32")

Kali ini, kita tambahkan keterangan dtype="float32". Ini penting, karena TensorFlow biasanya menangani float32 (yaitu tipe data float dengan penyimpanan 32-bit), bukan float64 yang biasa digunakan oleh pandas.

df

	x	y	kelas
0	-0.109873	2.904561	0.0
1	-0.070282	3.484931	0.0
2	-0.556087	3.335495	0.0
3	-0.314094	3.379053	0.0
4	-0.636380	2.201054	0.0
...	...	...	...
1995	3.338591	0.450919	1.0
1996	3.168565	0.507815	1.0
1997	1.506407	-0.884150	1.0
1998	1.901459	-0.520556	1.0
1999	1.771375	-0.421099	1.0

2000 rows × 3 columns

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2000 entries, 0 to 1999
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   x       2000 non-null   float32
 1   y       2000 non-null   float32
 2   kelas   2000 non-null   float32
dtypes: float32(3)
memory usage: 23.6 KB

inputs_df = df.drop(columns=["kelas"])
targets_df = df[["kelas"]]

inputs_df

	x	y
0	-0.109873	2.904561
1	-0.070282	3.484931
2	-0.556087	3.335495
3	-0.314094	3.379053
4	-0.636380	2.201054
...	...	...
1995	3.338591	0.450919
1996	3.168565	0.507815
1997	1.506407	-0.884150
1998	1.901459	-0.520556
1999	1.771375	-0.421099

2000 rows × 2 columns

targets_df

	kelas
0	0.0
1	0.0
2	0.0
3	0.0
4	0.0
...	...
1995	1.0
1996	1.0
1997	1.0
1998	1.0
1999	1.0

2000 rows × 1 columns

plt.scatter(inputs_df["x"], inputs_df["y"], c=targets_df["kelas"])
plt.show()

TensorFlow kurang bisa menangani pandas DataFrame, sehingga harus kita ubah jadi array numpy:

inputs = inputs_df.to_numpy()
targets = targets_df.to_numpy()

print(inputs.shape)
print(targets.shape)

(2000, 2)
(2000, 1)

Menyusun model dan training

Untuk input dua dimensi dan klasifikasi biner, kita perlu perceptron dengan dua neuron di input layer dan satu neuron di output layer. Sebelum proses training dimulai, nilai matriks \(W\) dan vektor kolom \(b\) diisi secara random terlebih dahulu.

input_dim = 2
output_dim = 1
W = tf.Variable(tf.random.normal(shape = (input_dim, output_dim)))
b = tf.Variable(tf.random.normal(shape = (output_dim,)))

# forward pass
def model(inputs):
    return tf.sigmoid(
        tf.matmul(inputs, W) + b
    )

# cross entropy loss
def entropy_loss(y, yhat):
    per_sample_losses = - y * tf.math.log(yhat) - (1-y) * tf.math.log(1-yhat)
    return tf.reduce_mean(per_sample_losses)

# satu epoch di training loop
learning_rate = 0.1
def training_step(inputs, targets):
    with tf.GradientTape() as tape:
        predictions = model(inputs)
        loss = entropy_loss(targets, predictions)

        grad_loss_wrt_W, grad_loss_wrt_b = tape.gradient(loss, [W, b])

        # update menggunakan gradient descent
        W.assign_sub(learning_rate * grad_loss_wrt_W)
        b.assign_sub(learning_rate * grad_loss_wrt_b)

        return loss

# training loop
for epoch in range(100):
    loss = training_step(inputs, targets)
    print(f"Loss at epoch {epoch}: {loss}")

Loss at epoch 0: 0.37649667263031006
Loss at epoch 1: 0.33892661333084106
Loss at epoch 2: 0.3085114061832428
Loss at epoch 3: 0.28344419598579407
Loss at epoch 4: 0.2624468505382538
Loss at epoch 5: 0.24460428953170776
Loss at epoch 6: 0.2292504459619522
Loss at epoch 7: 0.21589185297489166
Loss at epoch 8: 0.2041565477848053
Loss at epoch 9: 0.19375956058502197
Loss at epoch 10: 0.1844790279865265
Loss at epoch 11: 0.1761399507522583
Loss at epoch 12: 0.1686023324728012
Loss at epoch 13: 0.16175292432308197
Loss at epoch 14: 0.15549910068511963
Loss at epoch 15: 0.14976432919502258
Loss at epoch 16: 0.14448483288288116
Loss at epoch 17: 0.13960705697536469
Loss at epoch 18: 0.13508561253547668
Loss at epoch 19: 0.13088177144527435
Loss at epoch 20: 0.1269623339176178
Loss at epoch 21: 0.12329864501953125
Loss at epoch 22: 0.119865782558918
Loss at epoch 23: 0.1166420504450798
Loss at epoch 24: 0.11360841244459152
Loss at epoch 25: 0.11074810475111008
Loss at epoch 26: 0.10804630815982819
Loss at epoch 27: 0.10548984259366989
Loss at epoch 28: 0.10306701809167862
Loss at epoch 29: 0.1007673367857933
Loss at epoch 30: 0.09858141094446182
Loss at epoch 31: 0.09650078415870667
Loss at epoch 32: 0.09451782703399658
Loss at epoch 33: 0.09262565523386002
Loss at epoch 34: 0.09081799536943436
Loss at epoch 35: 0.08908917009830475
Loss at epoch 36: 0.08743401616811752
Loss at epoch 37: 0.08584779500961304
Loss at epoch 38: 0.08432614803314209
Loss at epoch 39: 0.08286512643098831
Loss at epoch 40: 0.08146108686923981
Loss at epoch 41: 0.08011066168546677
Loss at epoch 42: 0.07881075888872147
Loss at epoch 43: 0.07755852490663528
Loss at epoch 44: 0.07635130733251572
Loss at epoch 45: 0.07518665492534637
Loss at epoch 46: 0.0740623027086258
Loss at epoch 47: 0.07297613471746445
Loss at epoch 48: 0.07192617654800415
Loss at epoch 49: 0.07091060280799866
Loss at epoch 50: 0.06992770731449127
Loss at epoch 51: 0.06897588819265366
Loss at epoch 52: 0.06805365532636642
Loss at epoch 53: 0.06715962290763855
Loss at epoch 54: 0.06629245728254318
Loss at epoch 55: 0.06545095145702362
Loss at epoch 56: 0.06463393568992615
Loss at epoch 57: 0.06384031474590302
Loss at epoch 58: 0.06306910514831543
Loss at epoch 59: 0.062319304794073105
Loss at epoch 60: 0.06159002706408501
Loss at epoch 61: 0.06088041514158249
Loss at epoch 62: 0.060189660638570786
Loss at epoch 63: 0.05951699614524841
Loss at epoch 64: 0.05886170268058777
Loss at epoch 65: 0.058223091065883636
Loss at epoch 66: 0.057600509375333786
Loss at epoch 67: 0.056993357837200165
Loss at epoch 68: 0.05640103667974472
Loss at epoch 69: 0.055823005735874176
Loss at epoch 70: 0.05525872856378555
Loss at epoch 71: 0.05470770224928856
Loss at epoch 72: 0.05416945740580559
Loss at epoch 73: 0.05364353582262993
Loss at epoch 74: 0.053129516541957855
Loss at epoch 75: 0.05262697488069534
Loss at epoch 76: 0.05213551968336105
Loss at epoch 77: 0.05165477842092514
Loss at epoch 78: 0.05118439346551895
Loss at epoch 79: 0.050724029541015625
Loss at epoch 80: 0.050273347645998
Loss at epoch 81: 0.049832046031951904
Loss at epoch 82: 0.049399811774492264
Loss at epoch 83: 0.04897637292742729
Loss at epoch 84: 0.048561446368694305
Loss at epoch 85: 0.04815478250384331
Loss at epoch 86: 0.04775610938668251
Loss at epoch 87: 0.047365207225084305
Loss at epoch 88: 0.0469818189740181
Loss at epoch 89: 0.04660574346780777
Loss at epoch 90: 0.04623674973845482
Loss at epoch 91: 0.04587464779615402
Loss at epoch 92: 0.045519232749938965
Loss at epoch 93: 0.045170318335294724
Loss at epoch 94: 0.04482771083712578
Loss at epoch 95: 0.044491250067949295
Loss at epoch 96: 0.04416074976325035
Loss at epoch 97: 0.043836068361997604
Loss at epoch 98: 0.04351703077554703
Loss at epoch 99: 0.04320349544286728

Prediksi

Sekarang training sudah selesai, kita bisa gunakan model kita untuk memprediksi kelas berdasarkan inputs (koordinat titik-titik)

predictions = model(inputs)

Akibat penggunaan fungsi aktivasi sigmoid, hasil prediksi cukup jelas, apakah kelas pertama (kelas 0) atau kelas kedua (kelas 1):

print(predictions)

tf.Tensor(
[[0.01171741]
 [0.00699979]
 [0.00357984]
 ...
 [0.8950965 ]
 [0.9203457 ]
 [0.8933534 ]], shape=(2000, 1), dtype=float32)

Kita bisa menampilkan hasil prediksi ini dengan aturan pemilihan warna (c) seperti berikut:

apabila nilai prediksinya lebih dari 0.5 (pernyataan “lebih besar dari 0.5” bernilai benar), ia tergolong kelas 1 (atau sama saja nilai True);
selain itu (pernyataan “lebih besar dari 0.5” bernilai salah), ia tergolong kelas 0 (atau sama saja nilai False).

plt.scatter(inputs[:, 0], inputs[:, 1], c=predictions[:, 0] > 0.5)
plt.show()

Kinerja perceptron cukup mirip regresi logistik, ataupun SVM dengan kernel linier. Perhatikan bahwa, di hasil prediksi ini, seolah-olah ada perbatasan atau garis pemisah antara kedua kelas. Kalau kita bandingkan dengan data aslinya, sebenarnya ada beberapa titik yang melewati perbatasan tersebut, dan akhirnya terjadi misklasifikasi.

Mengenal Keras dengan Sequential API

Dengan pure TensorFlow, banyak hal yang harus kita susun secara manual. Untuk neural network kecil seperti perceptron, mungkin tidak masalah. Namun, neural network pada umumnya sangat “dalam” atau deep, dengan puluhan hidden layer yang bervariasi.

Daripada benar-benar membuatnya semua secara manual, ada yang namanya Keras yang sangat menyederhanakan proses penyusunan neural network. Biasanya, daripada benar-benar membuat neural network secara manual dalam pure TensorFlow seperti tadi, pengguna TensorFlow memanfaatkan Keras.

Keras tersedia di dalam TensorFlow:

from tensorflow import keras

Perlu dicatat, ketika menggunakan Keras, sebaiknya semua fungsi/operasi yang kita gunakan juga dari dalam Keras daripada langsung dari TensorFlow. Misalnya, daripada tf.matmul, gunakan keras.ops.matmul

Tapi kalau error, tidak masalah masih menggunakan tf karena Keras masih dalam pengembangan (menuju Keras versi 3, bisa dibaca di sini: https://keras.io/guides/migrating_to_keras_3/). Mungkin, di versi yang akan datang, sudah tidak error lagi.

Dalam Keras, ada tiga “cara” atau API (application programming interface) yang bisa kita gunakan untuk menyusun neural network, yaitu

Sequential API
Functional API
Subclassing API (yaitu dengan OOP)

Di pertemuan kali ini, kita akan mencoba cara yang paling sederhana, yaitu dengan Sequential API.

Datanya sudah siap dari yang tadi:

print(inputs.shape)
print(targets.shape)

(2000, 2)
(2000, 1)

Menyusun layer

Kita susun layer nya terlebih dahulu. Kali ini, kita akan membuat perceptron seperti yang cara manual / pure TensorFlow tadi. Untuk itu, kedua kode ini ekuivalen:

# langsung menentukan semua layer di awal, dengan memasukkan list
model2 = keras.Sequential(
    [
        keras.layers.InputLayer(input_shape = (2,)),
        keras.layers.Dense(units = 1, activation = 'sigmoid')
    ]
)

/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/input_layer.py:27: UserWarning: Argument `input_shape` is deprecated. Use `shape` instead.
  warnings.warn(

# menambahkan layer secara berangsur-angsur
model2 = keras.Sequential()
model2.add(keras.layers.InputLayer(input_shape = (2,)))
model2.add(keras.layers.Dense(units = 1, activation = 'sigmoid'))

Daripada menggunakan string, untuk menentukan fungsi aktivasi di kedua cara di atas, kita juga bisa mengetik keras.activations.sigmoid seperti berikut:

# langsung menentukan semua layer di awal, dengan memasukkan list
model2 = keras.Sequential(
    [
        keras.layers.InputLayer(input_shape = (2,)),
        keras.layers.Dense(units = 1, activation = keras.activations.sigmoid)
    ]
)

# menambahkan layer secara berangsur-angsur
model2 = keras.Sequential()
model2.add(keras.layers.InputLayer(input_shape = (2,)))
model2.add(keras.layers.Dense(units = 1, activation = keras.activations.sigmoid))

Ringkasan dan diagram model

Kemudian, kita bisa melihat ringkasan bentuk model yang dihasilkan:

model2.summary()

Model: "sequential_2"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ dense_2 (Dense)                 │ (None, 1)              │             3 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 3 (12.00 B)

 Trainable params: 3 (12.00 B)

 Non-trainable params: 0 (0.00 B)

Kita juga bisa menampilkan semacam diagram, bahkan menyimpannya ke dalam file:

keras.utils.plot_model(
    model2,
    show_shapes = True,
    show_layer_activations = True,
    to_file = "keras_sequential_model2.png"
)

Memilih hyperparameter

Untuk memilih hyperparameter yaitu optimizer dan loss function (dan metrik evaluasi), kedua kode berikut ini ekuivalen:

# dengan string
model2.compile(
    optimizer = "sgd",
    loss = "binary_crossentropy",
    metrics = ["binary_accuracy"]
)

# dengan objek dari class
model2.compile(
    optimizer = keras.optimizers.SGD(),
    loss = keras.losses.BinaryCrossentropy(),
    metrics = [keras.metrics.BinaryAccuracy()]
)

Dengan cara yang kedua, kita juga bisa menentukan hyperparameter seperti learning rate:

# dengan objek dari class
model2.compile(
    optimizer = keras.optimizers.SGD(learning_rate = 0.01),
    loss = keras.losses.BinaryCrossentropy(),
    metrics = [keras.metrics.BinaryAccuracy()]
)

Training

Selanjutnya, tinggal training, menggunakan .fit seperti di scikit-learn. Bedanya, .fit di sini me-return suatu objek “history” yang berisi catatan loss di tiap epoch

x_train = inputs
y_train = targets
history2 = model2.fit(x_train, y_train, epochs=100, validation_split=0.2)

Epoch 1/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 1s 7ms/step - binary_accuracy: 0.9829 - loss: 0.1602 - val_binary_accuracy: 0.9775 - val_loss: 0.2491
Epoch 2/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9909 - loss: 0.1308 - val_binary_accuracy: 0.9875 - val_loss: 0.1955
Epoch 3/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9930 - loss: 0.1074 - val_binary_accuracy: 0.9925 - val_loss: 0.1616
Epoch 4/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9975 - loss: 0.0915 - val_binary_accuracy: 0.9950 - val_loss: 0.1385
Epoch 5/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9981 - loss: 0.0834 - val_binary_accuracy: 1.0000 - val_loss: 0.1218
Epoch 6/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9963 - loss: 0.0775 - val_binary_accuracy: 1.0000 - val_loss: 0.1092
Epoch 7/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9953 - loss: 0.0732 - val_binary_accuracy: 1.0000 - val_loss: 0.0993
Epoch 8/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9981 - loss: 0.0700 - val_binary_accuracy: 1.0000 - val_loss: 0.0914
Epoch 9/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9993 - loss: 0.0607 - val_binary_accuracy: 1.0000 - val_loss: 0.0847
Epoch 10/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9990 - loss: 0.0581 - val_binary_accuracy: 1.0000 - val_loss: 0.0792
Epoch 11/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9981 - loss: 0.0590 - val_binary_accuracy: 1.0000 - val_loss: 0.0744
Epoch 12/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9994 - loss: 0.0585 - val_binary_accuracy: 1.0000 - val_loss: 0.0703
Epoch 13/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9999 - loss: 0.0521 - val_binary_accuracy: 1.0000 - val_loss: 0.0667
Epoch 14/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9987 - loss: 0.0479 - val_binary_accuracy: 1.0000 - val_loss: 0.0635
Epoch 15/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9990 - loss: 0.0466 - val_binary_accuracy: 1.0000 - val_loss: 0.0607
Epoch 16/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9997 - loss: 0.0442 - val_binary_accuracy: 1.0000 - val_loss: 0.0582
Epoch 17/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9995 - loss: 0.0446 - val_binary_accuracy: 1.0000 - val_loss: 0.0559
Epoch 18/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9993 - loss: 0.0423 - val_binary_accuracy: 1.0000 - val_loss: 0.0538
Epoch 19/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9993 - loss: 0.0410 - val_binary_accuracy: 1.0000 - val_loss: 0.0519
Epoch 20/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9994 - loss: 0.0414 - val_binary_accuracy: 1.0000 - val_loss: 0.0501
Epoch 21/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9999 - loss: 0.0396 - val_binary_accuracy: 1.0000 - val_loss: 0.0485
Epoch 22/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9995 - loss: 0.0345 - val_binary_accuracy: 1.0000 - val_loss: 0.0470
Epoch 23/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0372 - val_binary_accuracy: 1.0000 - val_loss: 0.0456
Epoch 24/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0358 - val_binary_accuracy: 1.0000 - val_loss: 0.0443
Epoch 25/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9995 - loss: 0.0342 - val_binary_accuracy: 1.0000 - val_loss: 0.0431
Epoch 26/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 0.9999 - loss: 0.0330 - val_binary_accuracy: 1.0000 - val_loss: 0.0420
Epoch 27/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 0.9999 - loss: 0.0319 - val_binary_accuracy: 1.0000 - val_loss: 0.0409
Epoch 28/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 0.9999 - loss: 0.0316 - val_binary_accuracy: 1.0000 - val_loss: 0.0399
Epoch 29/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 0.9991 - loss: 0.0316 - val_binary_accuracy: 1.0000 - val_loss: 0.0390
Epoch 30/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 0.9999 - loss: 0.0280 - val_binary_accuracy: 1.0000 - val_loss: 0.0381
Epoch 31/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 7ms/step - binary_accuracy: 0.9996 - loss: 0.0302 - val_binary_accuracy: 1.0000 - val_loss: 0.0372
Epoch 32/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9985 - loss: 0.0287 - val_binary_accuracy: 1.0000 - val_loss: 0.0364
Epoch 33/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9994 - loss: 0.0277 - val_binary_accuracy: 1.0000 - val_loss: 0.0357
Epoch 34/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9995 - loss: 0.0282 - val_binary_accuracy: 1.0000 - val_loss: 0.0349
Epoch 35/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9990 - loss: 0.0257 - val_binary_accuracy: 1.0000 - val_loss: 0.0342
Epoch 36/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0273 - val_binary_accuracy: 1.0000 - val_loss: 0.0336
Epoch 37/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9993 - loss: 0.0269 - val_binary_accuracy: 1.0000 - val_loss: 0.0330
Epoch 38/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9987 - loss: 0.0259 - val_binary_accuracy: 1.0000 - val_loss: 0.0324
Epoch 39/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9994 - loss: 0.0287 - val_binary_accuracy: 1.0000 - val_loss: 0.0318
Epoch 40/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9990 - loss: 0.0263 - val_binary_accuracy: 1.0000 - val_loss: 0.0312
Epoch 41/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9972 - loss: 0.0269 - val_binary_accuracy: 1.0000 - val_loss: 0.0307
Epoch 42/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9995 - loss: 0.0229 - val_binary_accuracy: 1.0000 - val_loss: 0.0302
Epoch 43/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0241 - val_binary_accuracy: 1.0000 - val_loss: 0.0297
Epoch 44/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9996 - loss: 0.0246 - val_binary_accuracy: 1.0000 - val_loss: 0.0292
Epoch 45/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9991 - loss: 0.0222 - val_binary_accuracy: 1.0000 - val_loss: 0.0288
Epoch 46/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9995 - loss: 0.0240 - val_binary_accuracy: 1.0000 - val_loss: 0.0283
Epoch 47/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9999 - loss: 0.0226 - val_binary_accuracy: 1.0000 - val_loss: 0.0279
Epoch 48/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9987 - loss: 0.0213 - val_binary_accuracy: 1.0000 - val_loss: 0.0275
Epoch 49/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9988 - loss: 0.0217 - val_binary_accuracy: 1.0000 - val_loss: 0.0271
Epoch 50/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9987 - loss: 0.0250 - val_binary_accuracy: 1.0000 - val_loss: 0.0267
Epoch 51/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9984 - loss: 0.0224 - val_binary_accuracy: 1.0000 - val_loss: 0.0264
Epoch 52/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9996 - loss: 0.0217 - val_binary_accuracy: 1.0000 - val_loss: 0.0260
Epoch 53/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9986 - loss: 0.0192 - val_binary_accuracy: 1.0000 - val_loss: 0.0256
Epoch 54/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9999 - loss: 0.0205 - val_binary_accuracy: 1.0000 - val_loss: 0.0253
Epoch 55/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9998 - loss: 0.0210 - val_binary_accuracy: 1.0000 - val_loss: 0.0250
Epoch 56/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9999 - loss: 0.0185 - val_binary_accuracy: 1.0000 - val_loss: 0.0247
Epoch 57/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9986 - loss: 0.0193 - val_binary_accuracy: 1.0000 - val_loss: 0.0244
Epoch 58/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9991 - loss: 0.0210 - val_binary_accuracy: 1.0000 - val_loss: 0.0241
Epoch 59/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 1.0000 - loss: 0.0216 - val_binary_accuracy: 1.0000 - val_loss: 0.0238
Epoch 60/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9999 - loss: 0.0200 - val_binary_accuracy: 1.0000 - val_loss: 0.0235
Epoch 61/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9989 - loss: 0.0207 - val_binary_accuracy: 1.0000 - val_loss: 0.0232
Epoch 62/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9991 - loss: 0.0184 - val_binary_accuracy: 1.0000 - val_loss: 0.0230
Epoch 63/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9990 - loss: 0.0198 - val_binary_accuracy: 1.0000 - val_loss: 0.0227
Epoch 64/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9997 - loss: 0.0180 - val_binary_accuracy: 1.0000 - val_loss: 0.0224
Epoch 65/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9992 - loss: 0.0187 - val_binary_accuracy: 1.0000 - val_loss: 0.0222
Epoch 66/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9999 - loss: 0.0181 - val_binary_accuracy: 1.0000 - val_loss: 0.0220
Epoch 67/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9996 - loss: 0.0166 - val_binary_accuracy: 1.0000 - val_loss: 0.0217
Epoch 68/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9989 - loss: 0.0183 - val_binary_accuracy: 1.0000 - val_loss: 0.0215
Epoch 69/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0176 - val_binary_accuracy: 1.0000 - val_loss: 0.0213
Epoch 70/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 1.0000 - loss: 0.0161 - val_binary_accuracy: 1.0000 - val_loss: 0.0211
Epoch 71/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - binary_accuracy: 0.9993 - loss: 0.0180 - val_binary_accuracy: 1.0000 - val_loss: 0.0208
Epoch 72/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 0.9989 - loss: 0.0192 - val_binary_accuracy: 1.0000 - val_loss: 0.0206
Epoch 73/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - binary_accuracy: 1.0000 - loss: 0.0165 - val_binary_accuracy: 1.0000 - val_loss: 0.0204
Epoch 74/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - binary_accuracy: 1.0000 - loss: 0.0179 - val_binary_accuracy: 1.0000 - val_loss: 0.0202
Epoch 75/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9988 - loss: 0.0169 - val_binary_accuracy: 1.0000 - val_loss: 0.0200
Epoch 76/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9996 - loss: 0.0157 - val_binary_accuracy: 1.0000 - val_loss: 0.0198
Epoch 77/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9991 - loss: 0.0186 - val_binary_accuracy: 1.0000 - val_loss: 0.0197
Epoch 78/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9996 - loss: 0.0164 - val_binary_accuracy: 1.0000 - val_loss: 0.0195
Epoch 79/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0157 - val_binary_accuracy: 1.0000 - val_loss: 0.0193
Epoch 80/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9992 - loss: 0.0143 - val_binary_accuracy: 1.0000 - val_loss: 0.0191
Epoch 81/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 1.0000 - loss: 0.0157 - val_binary_accuracy: 1.0000 - val_loss: 0.0190
Epoch 82/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0157 - val_binary_accuracy: 1.0000 - val_loss: 0.0188
Epoch 83/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9996 - loss: 0.0153 - val_binary_accuracy: 1.0000 - val_loss: 0.0186
Epoch 84/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 1.0000 - loss: 0.0149 - val_binary_accuracy: 1.0000 - val_loss: 0.0185
Epoch 85/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9989 - loss: 0.0161 - val_binary_accuracy: 1.0000 - val_loss: 0.0183
Epoch 86/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9978 - loss: 0.0161 - val_binary_accuracy: 1.0000 - val_loss: 0.0182
Epoch 87/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9998 - loss: 0.0156 - val_binary_accuracy: 1.0000 - val_loss: 0.0180
Epoch 88/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9997 - loss: 0.0140 - val_binary_accuracy: 1.0000 - val_loss: 0.0179
Epoch 89/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9996 - loss: 0.0151 - val_binary_accuracy: 1.0000 - val_loss: 0.0177
Epoch 90/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9999 - loss: 0.0154 - val_binary_accuracy: 1.0000 - val_loss: 0.0176
Epoch 91/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9999 - loss: 0.0136 - val_binary_accuracy: 1.0000 - val_loss: 0.0174
Epoch 92/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9993 - loss: 0.0138 - val_binary_accuracy: 1.0000 - val_loss: 0.0173
Epoch 93/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9991 - loss: 0.0152 - val_binary_accuracy: 1.0000 - val_loss: 0.0172
Epoch 94/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9999 - loss: 0.0134 - val_binary_accuracy: 1.0000 - val_loss: 0.0170
Epoch 95/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - binary_accuracy: 0.9991 - loss: 0.0143 - val_binary_accuracy: 1.0000 - val_loss: 0.0169
Epoch 96/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9987 - loss: 0.0169 - val_binary_accuracy: 1.0000 - val_loss: 0.0168
Epoch 97/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 1.0000 - loss: 0.0140 - val_binary_accuracy: 1.0000 - val_loss: 0.0166
Epoch 98/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9997 - loss: 0.0142 - val_binary_accuracy: 1.0000 - val_loss: 0.0165
Epoch 99/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9990 - loss: 0.0130 - val_binary_accuracy: 1.0000 - val_loss: 0.0164
Epoch 100/100
50/50 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - binary_accuracy: 0.9994 - loss: 0.0154 - val_binary_accuracy: 1.0000 - val_loss: 0.0163

Objek “history” tersebut memiliki dictionary .history. Kita bisa lihat, apa saja key yang ada:

print(history2.history.keys())

dict_keys(['binary_accuracy', 'loss', 'val_binary_accuracy', 'val_loss'])

Tiap key menyimpan data per epoch, sehingga ukurannya sama semua. Oleh karena itu, sebenarnya dictionary ini bisa diubah menjadi pandas DataFrame, yang kemudian bisa kita simpan ke CSV:

pd.DataFrame(history2.history).to_csv("./keras_sequential_history2.csv", index=False)

Kalau mau menyamakan, file nya bisa kalian download dari GitHub Pages ini: keras_sequential_history2.csv

Kemudian, kita bisa load kembali:

history2_df = pd.read_csv("./keras_sequential_history2.csv")

history2_df

	binary_accuracy	loss	val_binary_accuracy	val_loss
0	0.985000	0.150636	0.9775	0.249056
1	0.993125	0.122728	0.9875	0.195455
2	0.993750	0.105114	0.9925	0.161598
3	0.996250	0.092837	0.9950	0.138501
4	0.996875	0.083684	1.0000	0.121808
...	...	...	...	...
95	0.999375	0.014503	1.0000	0.016765
96	0.999375	0.014412	1.0000	0.016639
97	0.999375	0.014322	1.0000	0.016516
98	0.999375	0.014234	1.0000	0.016394
99	0.999375	0.014146	1.0000	0.016273

100 rows × 4 columns

Dua catatan yang paling sering diperhatikan adalah loss (training loss) dan juga val_loss (validation loss). Bahkan, seringkali kedua nilai ini dibuat gambar plotnya (terhadap epoch), untuk menganalisis bagaimana proses training model.

plt.plot(history2_df["loss"], label = "training loss")
plt.plot(history2_df["val_loss"], label = "validation loss")
plt.xlabel("epoch")
plt.legend()
plt.show()

Proses training tenryata berjalan dengan sangat baik! Kali ini, baik training loss maupun validation loss turun secara drastis dan terus menuju nol.

Biasanya, walaupun training loss tidak mungkin naik, terkadang validation loss naik turun, yang bisa jadi pertanda overfitting.

Menggunakan model

Seperti di scikit-learn, panggil .predict() untuk melakukan prediksi

predictions2 = model2.predict(inputs)

63/63 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step

Ada sedikit progress bar, karena proses prediksi sebenarnya adalah forward pass. Kita bisa matikan progress bar dengan verbose=False

predictions2 = model2.predict(inputs, verbose=False)

print(predictions2)

[[2.0281430e-03]
 [6.6396926e-04]
 [3.5774685e-04]
 ...
 [9.9074566e-01]
 [9.9079442e-01]
 [9.8560268e-01]]

plt.scatter(inputs[:, 0], inputs[:, 1], c=predictions2[:, 0] > 0.5)
plt.show()

Menyimpan keseluruhan model

Perintahnya adalah .save(path_tempat_penyimpanan) dengan file format .keras

model2.save("./keras_sequential_model2.keras")

Kita bisa load kembali model tersebut:

model3 = keras.models.load_model("keras_sequential_model2.keras")

Hasil prediksinya akan sama (karena modelnya memang sama):

predictions3 = model3.predict(inputs)

63/63 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step

np.array_equal(predictions2, predictions3)

True

Menyimpan parameter model (saja)

Daripada menyimpan keseluruhan model, kita bisa menyimpan weights atau parameternya saja, dengan perintah .save_weights(path_tempat_penyimpanan) dan file format .weights.h5

model2.save_weights("keras_sequential_model2.weights.h5")

Untuk load kembali, kita perlu menyusun layer model terlebih dahulu, sama persis dengan susunan yang aslinya:

model4 = keras.Sequential(
    [
        keras.layers.InputLayer(input_shape = (2,)),
        keras.layers.Dense(units = 1, activation = keras.activations.sigmoid)
    ]
)

/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/input_layer.py:27: UserWarning: Argument `input_shape` is deprecated. Use `shape` instead.
  warnings.warn(

Barulah kita gunakan perintah .load_weights(path_tempat_penyimpanan)

model4.load_weights("./keras_sequential_model2.weights.h5")

Lagi-lagi, hasil prediksinya akan sama:

predictions4 = model4.predict(inputs)

63/63 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step

np.array_equal(predictions2, predictions4)

True

Perhatikan bahwa kita belum memanggil model4.compile, artinya kita belum memasang hyperparameter. Meskipun demikian, kita masih bisa melakukan prediksi, karena proses prediksi hanyalah forward pass, yang hanya membutuhkan parameter (weights and biases), yang memang sudah di-load.

Setelah melakukan model4.compile, dengan hyperparameter yang bahkan tidak harus sama dengan yang aslinya, kita bisa melanjutkan proses training kalau mau.

Mengapa tidak save keseluruhan model saja? Selain lebih hemat memori, contoh kasusnya, kita ingin menyimpan progress dari training model, yang sebenarnya susunan layer nya kita ketahui dengan pasti, seperti contoh model4 di atas.

(Pengayaan) Daftar pilihan hyperparameter di Keras

Pilihan fungsi aktivasi

Umum digunakan

Linier (identitas): keras.activations.linear
Sigmoid: keras.activations.sigmoid
ReLU: keras.activations.relu
(Soft) tanh: keras.activations.tanh
Softmax: keras.activations.softmax

Lainnya

Relu6: keras.activations.relu6

\[\Phi(x) = \min \{ \text{ReLU}(x), 6 \}\]
Leaky ReLU: keras.activations.leaky_relu

bisa dipasang hyperparameter \(\alpha \ge 0\): negative_slope

\[\Phi(x) = \max \{x, \alpha x\}\]
ELU (Exponential Linear Unit): keras.activations.elu

bisa dipasang hyperparameter \(\alpha \ge 0\): alpha

\[ \Phi(x) = \begin{cases} x & x > 0 \\ \alpha (e^x - 1) & \text{otherwise} \end{cases} \]
Softplus: keras.activations.softplus

\[\Phi(x) = \ln (e^x + 1)\]
Softsign: keras.activations.softsign

\[\Phi(x) = \frac{x}{|x| + 1}\]
Mish: keras.activations.mish

\[\Phi(x) = x \tanh (\text{softplus} (x))\]
Exponential: keras.activations.exponential
SELU (Scaled Exponential Linear Unit): keras.activations.selu
GELU (Gaussian error linear unit): keras.activations.gelu
Swish / Silu: keras.activatins.silu
Hard Silu: keras.activations.hard_silu
Hard sigmoid: keras.activations.hard_sigmoid
Log softmax: keras.activations.log_softmax

Sumber: https://keras.io/api/layers/activations/

Pilihan optimizer

Umum digunakan

SGD: keras.optimizers.SGD
Adam: keras.optimizers.Adam (saat ini dianggap optimizer terbaik)
RMSprop: keras.optimizers.RMSprop
Adagrad: keras.optimizers.Adagrad

Lainnya

AdamW: keras.optimizers.AdamW
Adadelta: keras.optimizers.Adadelta
Adamax: keras.optimizers.Adamax
Adafactor: keras.optimizers.Adafactor
Nadam: keras.optimizers.Nadam
Ftrl: keras.optimizers.Ftrl
Lion: keras.optimizers.Lion
Loss Scale Optimizer: keras.optimizers.LossScaleOptimizer

Kecuali Loss Scale Optimizer, semua optimizer bisa dipasang learning rate. Contohnya seperti berikut:

keras.optimizers.SGD(learning_rate=0.01)

Sumber: https://keras.io/api/optimizers/

Pilihan loss function

Umum digunakan

Binary cross-entropy (untuk klasifikasi biner)

class: keras.losses.BinaryCrossentropy

fungsi: keras.losses.binary_crossentropy
Categorial cross-entropy (untuk klasifikasi multiclass)

class: keras.losses.CategoricalCrossentropy

fungsi: keras.losses.categorical_crossentropy
MSE / mean squared error (untuk regresi)

class: keras.losses.MeanSquaredError

fungsi: keras.losses.mean_squared_error

Lainnya, untuk klasifikasi

Sparse categorical cross-entropy

class: keras.losses.SparseCategoricalCrossentropy

fungsi: keras.losses.spare_categorical_crossentropy
Poisson loss

class: keras.losses.Poisson

fungsi: keras.losses.poisson
Kullback-Leibler divergence loss

class: keras.losses.KLDivergence

fungsi: keras.losses.kl_divergence

Lainnya, untuk regresi

MAE / mean absolute error

class: keras.losses.MeanAbsoluteError

fungsi: keras.losses.mean_absolute_error
Mean absolute percentage error

class: keras.losses.MeanAbsolutePercentageError

fungsi: keras.losses.mean_absolute_percentage_error
Mean squared logarithmic error

class: keras.losses.MeanSquaredLogarithmicError

fungsi: keras.losses.mean_squared_logarithmic_error
Cosine similarity

class: keras.losses.CosineSimilarity

fungsi: keras.losses.cosine_similarity
Huber loss

class: keras.losses.Huber

fungsi: keras.losses.huber
Log Cosh loss

class: keras.losses.LogCosh

fungsi: keras.losses.log_cosh

Sumber: https://keras.io/api/losses/

Beberapa pilihan metrik evaluasi

Umum digunakan

Accuracy: keras.metrics.Accuracy
\(R^2\): keras.metrics.R2Score
Binary accuracy: keras.metrics.BinaryAccuracy
Categorical accuracy: keras.metrics.CategoricalAccuracy

Lainnya, untuk klasifikasi multiclass

Sparse categorical accuracy: keras.metrics.SpareCategoricalAccuracy
Top K categorical accuracy: keras.metrics.TopKCategoricalAccuracy
Spare top K categorical accuracy: keras.metrics.SpareTopKCategoricalAccuracy

Lainnya, untuk klasifikasi biner atau True/False

AUC: keras.metrics.AUC
Precision: keras.metrics.Precision
Recall: keras.metrics.Recall
True Positives: keras.metrics.TruePositives
True Negatives: keras.metrics.TrueNegatives
False Positives: keras.metrics.FalsePositives
False Negatives: keras.metrics.FalseNegatives
Precision at recall: keras.metrics.PrecisionAtRecall
Recall at precision: keras.metrics.RecallAtPrecision
Sensitivity at specificity: keras.metrics.SensitivityAtSpecificity
Specificity at sensitivity: keras.metrics.SpecificityAtSensitivity
F-1 score: keras.metrics.F1Score
F-Beta score: keras.metrics.FBetaScore

Semua pilihan loss function juga bisa digunakan sebagai metrik evaluasi.

Sumber: https://keras.io/api/metrics/

Referensi

Sumber gambar

Aggarwal, C. Charu. 2018. Neural Networks and Deep Learning: A Textbook. Edisi Pertama. Springer.
Goodfellow, Ian; Bengio, Yoshua; & Courville, Aaron. 2016. Deep Learning. MIT Press.

Buku lainnya

Géron, Aurélien. 2019. Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems. Edisi Kedua. O’Reilly Media.

Internet

Teori Neural Network

SLP: (Single-Layer) Perceptron

MLP: Multilayer Perceptron

Fungsi Aktivasi

Loss function

Proses training

Contoh optimizer: metode gradient descent

Train-Validation-Test Split

Mengenal TensorFlow

Tensor, Konstanta

Variabel dan assignment untuk tensor

Tensor random

Operasi TensorFlow seperti numpy

Automatic differentiation dengan GradientTape

(Pure) TensorFlow: klasifikasi biner dengan perceptron

Generate dataset

Import kembali dataset

Menyusun model dan training

Prediksi

Mengenal Keras dengan Sequential API

Menyusun layer

Ringkasan dan diagram model

Memilih hyperparameter

Training

Menggunakan model

Menyimpan keseluruhan model

Menyimpan parameter model (saja)

(Pengayaan) Daftar pilihan hyperparameter di Keras

Pilihan fungsi aktivasi

Pilihan optimizer

Pilihan loss function

Beberapa pilihan metrik evaluasi

Referensi

Automatic differentiation dengan `GradientTape`