Lu harus bersyukur Bre hidup di zaman sekarang. karena bikin model deep learning sekarang cuma butuh 5 step aja pake tensorflow. Step nya pendek-pendek lagi. Penasarin? Cekidot!
Lu udah tau kan, tensorflow tuh library buat ngembangin model deep learning. Di dalemnya ada banyak modul buat macem-macem tugas.
Eh, tapi ya, ada satu modul yang wajib banget lu inget kalo mau bikin model deep learning dasar. Namanya keras. Penting banget nih!
Di keras sendiri, alat-alatnya dikelompokin lagi jadi beberapa submodul. Gue kasih tau deh 5 submodul utama yang harus lu tau:
layers: Isinya layer-layer deep learning.models: Ini buat bikin model deep learning.datasets: Di sini ada dataset-dataset terkenal.losses: Isinya alat buat ngitung loss training.optimizers: Ini buat ngurusin training.
Gue anggep lu udah ngerti apa itu deep learning ya. Jadi, kita langsung gas aja bikin kodenya di TensorFlow.
Lu harus tau nih, ada 4 langkah penting buat bikin deep learning di TensorFlow:
0. Siapin dataset: Bikin train dataset sama test dataset.
- Susun Model: Di sini lu atur modelnya, berapa layer, berapa neuron, sama fungsi aktivasi apa yang dipake.
- Compile model: Siapin perlengkapan sebelum training. Tentuin fungsi loss, optimizer, sama metrik buat ngukur keberhasilan model.
- Fit model: Training model lu pake train dataset sampe dapet akurasi yang lu mau.
- Evaluasi model: Kalo model udah oke, lu bisa lakuin evaluasi atau bikin prediksi. Biasanya sih pake test dataset.
Yuk ah, daripada kebanyakan teori, mending kita langsung praktek. Kita bakal bikin model deep learning yang bisa ngenali data MNIST (foto angka 0 sampe 9).
Sebelum mulai ngoding, kita import dulu 5 submodul dari tensorflow.keras yang bakal kita pake.
import tensorflow.keras.models as models
import tensorflow.keras.layers as layers
import tensorflow.keras.datasets as datasets
import tensorflow.keras.losses as losses
import tensorflow.keras.optimizers as optimizers
Gue sengaja ngga langsung import alatnya, tapi submodulnya aja. Kenapa? Biar lu bisa tahu tiap alat itu asalnya dari mana.
Cus siapin dataset MNIST:
# Siapin dataset
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
print(x_train.shape) # (60000, 28, 28)
print(y_train.shape) # (60000,)
print(x_test.shape) # (10000, 28, 28)
print(y_test.shape) # (10000,)
Di sini, gue ambil dataset MNIST pake submodul datasets.mnist. Ini bakal ngasih kita dua tuple yang gue tangkep pake (x_train, y_train) sama (x_test, y_test).
Nah, abis itu kita perlu nge-reshape x_train sama x_test. Awalnya tiap data tuh kan ukurannya 28×28, kita perlu jadiin satu baris yang ukurannya 784.
# Reshape x_train dan x_test
x_train = x_train.reshape((-1, 28*28)).astype('float32') / 255.0
x_test = x_test.reshape(-1, 28*28).astype('float32') / 255.0
print(x_train.shape) # (60000, 784)
print(x_test.shape) # (10000, 784)
Nah, sekarang gue mau bikin model yang simpel, kaya gini:
Akan ada 3 layer, Bre: input, hidden, dan output layer. Kalo mau dibikin satu-satu, kaya gini kodenya:
input_layer = layers.Input(shape=(784)
hidden_layer = layers.Dense(128, activation='relu', name='hidden')
output_layer = layers.Dense(10, activation='softmax', name='output')
Coba lu lihat kodenya. Buat bikin input layer, kita pake kelasInput dari submodel layers. Sedangkan, buat bikin hidden dan output layer, kita pake kelas Dense
Oiya, FYI, kita juga bisa lho pisahin antara fungsi aktivasi dari Dense layer.
input_layer = layers.Input(shape=784)
hidden_layer = layers.Dense(128, name='hidden_layer')
hidden_activation_layer = layers.Activation('relu') # activation layer
output_layer = layers.Dense(10, name='output_layer')
output_activation_layer = layers.Activation('softmax') # activation layer
Istirahat dulu, Bre.
Lanjut. Yok sekarang kita susun layersnya.
Eh, tapi sebelum itu, lu tau nggak? Ternyata ada 3 cara buat nyusun layers di TensorFlow:
- Sequential Model pake array
- Sequential Model pake metode
add() - Functional Model
Gue bakal jelasin satu-satu, biar lu ngerti bedanya.
Sequential Model pake List
Cara nyusun layer pake Sequential list itu kaya gini:
# Sequential Model pake List
model = models.Sequential([
layers.Input(shape=(784)),
layers.Dense(128, activation='relu', name='hidden_layer'),
layers.Dense(10, activation='softmax', name='output_layer')
])
Pertama, kita panggil models.Sequential dari submodul models . Fungsinya buat bikin model. Selanjutnya, kita susun deh layer-layer yang kita butuhin di dalam list, terus kita masukin ke Sequential.
Sequential Model pake Metode add()
Cara nyusun layers pake Sequential + metode add() itu kaya gini:
# Sequential Model pake Metode add()
model = models.Sequential()
model.add(layers.Input(shape=(784)))
model.add(layers.Dense(128, activation='relu', name='hidden_layer'))
model.add(layers.Dense(10, activation='softmax', name='output_layer'))
Jadi, pertama panggil models.Sequential dulu. Terus secara bertahap kita tambahin layer di dalemnya pake metode .add()
Functional Model
Dari semua cara, functional model ini yang paling fleksibel buat nyusun layer! Kaya gini caranya:
inputs = layers.Input(shape=(784))
x = layers.Dense(128, activation='relu', name='hidden_layer')(inputs)
outputs = layers.Dense(10, activation='softmax', name='output_layer')(x)# Functional Model
model = models.Model(inputs=inputs, outputs=outputs)
lu liat baris terakhir kan? Gue manggil models.Model buat bikin model. Kelas ini cuma butuh dua hal: inputs sama outputs. Gampang kan?
Karena kemudahan ini, kita bisa lakuin apa yang kita suka. Misalnya, kita bisa loh bikin model yang punya 2 output sekaligus:
inputs = layers.Input(shape=(784))
x = layers.Dense(128, activation='relu', name='hidden_layer')(inputs)
outputs = layers.Dense(10, activation='softmax', name='output_layer')(x)
# bikin outputs2
outputs2 = layers.Dense(10, activation='softmax', name='output_layer2')(x)# Functional Model dua output
model = models.Model(inputs=inputs, outputs=[outputs, outputs2])
Abis nyusun model, yok siapin konfigurasi training model. Kaya gini contohnya:
model.compile(
loss=losses.SparseCategoricalCrossentropy(), # or loss='sparse_categorical_crossentropy'
optimizer=optimizers.Adam(learning_rate=0.001), # or optimizer='adam'
metrics=['accuracy']
)
Di konfigurasimodel.compile() ini, kita minimal tentuin 3 hal:
Buat nentuin loss, kita pake kelas yang ada di submodul losses (contoh: losses.SparseCategoricalCrossentropy) atau bisa langsung sebutin pake string. Bedanya, kalau pake submodul losses lebih fleksibel dan punya banyak settingan.
Buat nentuin optimizer, kita pake kelas yang ada di submodul optimizers (contoh: optimizers.Adam) atau bisa pake string langsung. Bedanya, kalau pake kelas, itu lebih fleksibel. Misalnya lu bisa tentuin learning_rate di Adam Optimizer kaya kode di atas.
Terus buat nentuin metrics, kita bisa langsung sebutin apa metriks yang kita ukur buat keberhasilan model. Di sini gue pake accuracy.
Oke, sekarang saatnya kita jalanin training. Lu tau lah ya, training itu maksudnya kita atur weight dan bias model supaya sesuai sama dataset. Cukup pake kode kaya gini:
model.fit(x_train, y_train, epochs=4, batch_size=64)
Jadi, kita perlu siapin x_train dan y_train. Tentuin juga berapa banyak epoch dan batch_size untuk tiap epoch. Terus tungguin ampe training selesai.
Setelah training selesai, saatnya pembuktian. Apakah model juga jalan di data yang belum pernah dilihat. Lu bisa lakuin evaluasi model atau langsung test prediksi model pake data test.
Buat evaluasi, jalanin metode .evaluate()
loss, accuracy = model.evaluate(x_test, y_test)
print(loss)
print(accuracy)
Buat prediksi langsung, jalanin metode .predict()
y_pred = model.predict(x_test)
Selamat! Yeay! Kita sudah bisa bikin model MNIST pake semua submodul yang ada di dalam tensorflow.keras. Ini list semua submodul tensorflow keras yang udah kita pake selama ini:
Seiring bertambah kompleksitas model kita, semakin banyak juga submodul dan tools yang kita pake dari tensorflow keras. Tapi, sekompleks apapun, konsepnya sama aja. Cuma butuh 5 step!
Lampiran
Kode lengkap project ini dapat dilihat di sini
Be the first to comment