Membuat Model Klasifikasi MNIST dengan TensorFlow

Dalam artikel ini, kita akan membahas cara membuat model klasifikasi untuk dataset MNIST menggunakan TensorFlow. Kita akan menggabungkan penjelasan tentang proses forward propagation, serta teknik lainnya seperti flattening dalam satu kesatuan kode Python.

import tensorflow as tf

# Load data
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Preprocess data
x_train = x_train.reshape(x_train.shape[0], 28 * 28).astype('float32') / 255
x_test = x_test.reshape(x_test.shape[0], 28 * 28).astype('float32') / 255

# Define the model
model = tf.keras.Sequential([
    tf.keras.layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Train the model
model.fit(x_train, y_train, epochs=5)

# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)

Penjelasan Kode

1. Mengimpor TensorFlow dan Memuat Data:

Pertama, kita mengimpor TensorFlow dan memuat dataset MNIST. Dataset ini dibagi menjadi data latih (x_train, y_train) dan data uji (x_test, y_test).

import tensorflow as tf

# Load data
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

2. Preprocessing Data:

Gambar pada dataset MNIST memiliki dimensi 28x28 piksel. Kita melakukan proses flatten (meratakan) dengan meresap ulang data tersebut menjadi vektor 1D dengan panjang 784 (28x28) dan menormalisasi nilai piksel ke rentang 0–1 dengan membaginya dengan 255.

# Preprocess data
x_train = x_train.reshape(x_train.shape[0], 28 * 28).astype('float32') / 255
x_test = x_test.reshape(x_test.shape[0], 28 * 28).astype('float32') / 255

3. Mendefinisikan Model :

Model kita adalah model sekuensial dengan dua lapisan Dense (fully connected). Lapisan pertama memiliki 512 neuron dengan fungsi aktivasi ReLU, dan lapisan kedua memiliki 10 neuron dengan fungsi aktivasi softmax untuk klasifikasi 10 kelas digit (0–9).

# Define the model
model = tf.keras.Sequential([
    tf.keras.layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
    tf.keras.layers.Dense(10, activation='softmax')
])

Pemilihan 512 neuron dalam lapisan dense didasarkan pada keseimbangan antara kompleksitas model dan kemampuan komputasi, pengalaman dan hasil yang baik dalam berbagai aplikasi, serta kompromi antara akurasi dan kompleksitas model.

Lapisan dense dipilih karena memang lapisan dense digunakan untuk mengklasifikasikan fitur yang diekstraksi dari lapisan konvolusi sebelumnya juga karena ini NN ini untuk deteksi sebuah gambar. maka koneksi penuh antara setiap neuron (fully connected layer) sangat penting sehingga lapisan dense dipilih

4. Forward Propagation :

Pada tahap ini, input berupa gambar digit yang telah di-flatten dan dinormalisasi mengalir melalui jaringan:

• Lapisan pertama: Input dikalikan dengan bobot, ditambahkan bias, lalu fungsi aktivasi ReLU diterapkan untuk memperkenalkan non-linearitas.
• Lapisan kedua: Output dari lapisan pertama dikalikan dengan bobot, ditambahkan bias, lalu fungsi aktivasi softmax menghasilkan probabilitas untuk setiap kelas.

5. Kompilasi Model:

Kita mengkompilasi model menggunakan optimizer Adam, loss function sparse_categorical_crossentropy, dan metrik accuracy untuk evaluasi.

# Compile the model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

5. Backpropagation dan Pelatihan Model:

Model dilatih selama 5 epoch menggunakan data latih. Selama proses ini, backpropagation digunakan untuk memperbarui bobot berdasarkan error antara output yang diprediksi dan output yang sebenarnya. Optimizer Adam menggunakan gradien ini untuk meminimalkan loss function.

# Train the model
model.fit(x_train, y_train, epochs=5)

5. Evaluasi Model

Setelah pelatihan, kita evaluasi model menggunakan data uji dan mencetak akurasi model.

# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)

Dalam kode di atas, kita melihat bagaimana forward propagation digunakan untuk menghasilkan prediksi, sementara backpropagation digunakan untuk memperbarui bobot sehingga model dapat belajar dan meningkatkan akurasinya. Flattening adalah salah satu teknik preprocessing penting yang mengubah gambar 2D menjadi vektor 1D yang dapat diinput ke dalam jaringan saraf.

Kalau boleh direkap prosesnya adalah

1. Forward Propagation = Input -> Hidden Layers -> Output Layer -> Predicted Value
2. Loss Calculation = Predicted Value + Ground Truth -> Loss Function -> Loss
3. Backward Propagation = Loss -> Gradien terhadap Bobot -> Gradien
4. Weight Update = Gradien -> Optimizer -> Perbarui Bobot
5. Epoch = Proses diulang dari Forward Propagation dengan bobot yang diperbarui.

Penjelasan :

Input (misal gambar mnist yg diubah menjadi vektor 1D dengan cara flatten) → Hidden layer (Setiap neuron di hidden layer menghitung weighted sum dari input dan menambah bias kemudian menerapkan fungsi aktivasi misalnya RELU) → Output dari hidden layer diteruskan ke output layer yg menghitung weighted sum dan tambah bias kemudian menerapkan fungsi aktivasi misalnya sofmax untuk klasifikasi