1. Pendahuluan

Dalam dunia pengolahan citra digital, salah satu permasalahan klasik yang menarik adalah image colorization, yaitu proses mengubah gambar hitam putih (grayscale) menjadi gambar berwarna.

Teknik ini memiliki banyak manfaat, seperti :

• Restorasi foto lama
• Pewarnaan arsip sejarah
• Industri film dan dokumenter
• Aplikasi kreatif berbasis AI

Dengan berkembangnya Deep Learning, khususnya Convolutional Neural Network (CNN), proses pewarnaan gambar kini dapat dilakukan secara otomatis dan realistis.

Framework yang sering digunakan untuk membangun model ini adalah TensorFlow, yang menyediakan kemudahan dalam membangun, melatih, dan menguji model neural network.

Pada artikel ini kita akan membahas :

1. Konsep dasar CNN untuk colorization
2. Persiapan dataset
3. Pembuatan model CNN
4. Proses training
5. Evaluasi dan visualisasi hasil

Artikel ini bersifat praktik langsung (hands-on), sehingga cocok untuk pembaca yang ingin memahami implementasi nyata.

2. Konsep Dasar Image Colorization

2.1 Representasi Warna dalam Gambar

Gambar digital biasanya direpresentasikan dalam format :

• RGB (Red, Green, Blue)
• Grayscale (1 channel saja)

Strategi umum colorization adalah :

• Input: channel L (lightness)
• Output: channel a dan b (warna)

Pendekatan ini biasanya menggunakan ruang warna Lab Color Space.

2.2 Peran CNN dalam Colorization

CNN sangat efektif dalam pengolahan citra karena :

• Mampu mendeteksi pola lokal (edges, texture)
• Mampu memahami struktur objek
• Memiliki weight sharing (efisien)

Dalam kasus ini :

• Input: gambar grayscale
• Output: prediksi warna untuk tiap piksel

Model belajar dengan cara meminimalkan error antara warna asli dan warna prediksi.

3. Persiapan Dataset & Tools

3.1 Masuk ke Google Colab

1. Buka browser
2. Kunjungi : https://colab.research.google.com
3. Login Gmail
4. Klik New Notebook

Sekarang kamu ada di halaman notebook kosong.

3.2 Aktifkan GPU (Penting!)

1. Klik menu Runtime
2. Klik Change runtime type
3. Pilih : Hardware accelerator → GPU
4. Klik Save

Kenapa penting? Karena training CNN tanpa GPU bisa sangat lambat.

Kita bisa menggunakan dataset umum seperti :

• CIFAR-10
• ImageNet subset
• Dataset pribadi

Untuk praktik sederhana, kita gunakan CIFAR-10 yang sudah tersedia di TensorFlow.

4. Langkah – Langkah

4.1 Import Library

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import cifar10

4.2 Load Dataset

(x_train, _), (x_test, _) = cifar10.load_data()

x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

print("Shape data training:", x_train.shape)

Output harus seperti : (50000, 32, 32, 3)

Artinya :

• 50000 gambar
• Ukuran 32×32
• 3 channel RGB

4.3 Konversi ke Grayscale

x_train_gray = tf.image.rgb_to_grayscale(x_train)
x_test_gray = tf.image.rgb_to_grayscale(x_test)

print("Shape grayscale:", x_train_gray.shape)

Output harus : (50000, 32, 32, 1)

Sekarang gambar hanya punya 1 channel.

4.4 Cek Visual Gambar

plt.figure(figsize=(6,3))

plt.subplot(1,2,1)
plt.imshow(x_train[0])
plt.title("Warna Asli")
plt.axis("off")

plt.subplot(1,2,2)
plt.imshow(tf.squeeze(x_train_gray[0]), cmap="gray")
plt.title("Grayscale")
plt.axis("off")

plt.show()

Kalau berhasil, kamu akan melihat:

• Kiri → gambar warna
• Kanan → versi hitam putih

5. Membangun Model CNN

model = models.Sequential()

# Encoder
model.add(layers.Conv2D(64, (3,3), activation='relu', padding='same', input_shape=(32,32,1)))
model.add(layers.MaxPooling2D((2,2)))

model.add(layers.Conv2D(128, (3,3), activation='relu', padding='same'))
model.add(layers.MaxPooling2D((2,2)))

# Decoder
model.add(layers.Conv2D(128, (3,3), activation='relu', padding='same'))
model.add(layers.UpSampling2D((2,2)))

model.add(layers.Conv2D(64, (3,3), activation='relu', padding='same'))
model.add(layers.UpSampling2D((2,2)))

model.add(layers.Conv2D(3, (3,3), activation='sigmoid', padding='same'))

model.summary()

Kalau muncul ringkasan layer → model berhasil dibuat

6. Compile dan Training Model

6.1 Compile Model

model.compile(
    optimizer='adam',
    loss='mse',
    metrics=['accuracy']
)

6.2 Training

history = model.fit(
    x_train_gray,
    x_train,
    epochs=10,
    batch_size=64,
    validation_split=0.2
)

Ini bagian yang lama. Kalau pakai GPU Colab → sekitar 3–5 menit, kalau tanpa GPU → bisa sangat lama.

7. Evaluasi dan Visualisasi

7.1 Prediksi

pred = model.predict(x_test_gray[:5])

7.2 Tampilkan Hasil

plt.figure(figsize=(12,6))

for i in range(5):
    # Grayscale
    plt.subplot(3,5,i+1)
    plt.imshow(x_test_gray[i].reshape(32,32), cmap='gray')
    plt.axis('off')

    # Prediksi
    plt.subplot(3,5,i+6)
    plt.imshow(pred[i])
    plt.axis('off')

    # Asli
    plt.subplot(3,5,i+11)
    plt.imshow(x_test[i])
    plt.axis('off')

plt.show()

Baris :

• Atas : grayscale
• Tengah : hasil prediksi
• Bawah : warna asli

Kalau warna mulai mirip → model berhasil belajar.

8. Analisis Hasil

Beberapa hal yang mungkin terjadi :

• Warna terlihat pudar
• Model bingung pada objek kompleks
• Dataset kecil → generalisasi kurang baik

Solusi peningkatan :

• Tambah dataset lebih besar
• Gunakan arsitektur U-Net
• Gunakan loss perceptual
• Transfer learning

9. Pengembangan Lebih Lanjut

Untuk hasil lebih realistis, bisa menggunakan :

• GAN (Generative Adversarial Network)
• Pretrained encoder seperti ResNet
• Dataset resolusi tinggi

Beberapa penelitian menggunakan arsitektur lanjutan untuk meningkatkan ketajaman warna.

10. Kesimpulan

Pada artikel ini kita telah mempelajari :

• Konsep image colorization
• Cara menggunakan CNN untuk memprediksi warna
• Implementasi menggunakan TensorFlow
• Evaluasi hasil model

CNN mampu mempelajari distribusi warna berdasarkan pola grayscale, namun kualitas sangat bergantung pada :

• Arsitektur
• Dataset
• Jumlah epoch
• Teknik loss function

Dengan pengembangan lebih lanjut, model colorization dapat menghasilkan gambar yang hampir menyerupai warna asli.