Tutorial SRGAN TensorFlow Keras Tingkatkan Resolusi Gambar

Meningkatkan resolusi gambar, atau yang dikenal sebagai Image Super-Resolution (SR), adalah proses fundamental dalam pengolahan citra digital yang bertujuan untuk merekonstruksi gambar beresolusi tinggi (High-Resolution/HR) dari gambar beresolusi rendah (Low-Resolution/LR). Teknik ini krusial dalam berbagai aplikasi Artificial Intelligence (AI) dan Computer Vision, mulai dari pencitraan medis, pengawasan satelit, hingga restorasi foto lama. Salah satu pendekatan paling canggih dan populer untuk tugas ini adalah Super-Resolution Generative Adversarial Network (SRGAN). SRGAN mampu menghasilkan gambar HR yang tidak hanya memiliki detail halus tetapi juga tampak fotorealistik, sebuah peningkatan signifikan dibandingkan metode interpolasi tradisional seperti bicubic. Dalam tutorial SRGAN TensorFlow Keras ini, kita akan membahas secara mendalam bagaimana cara mengimplementasikan SRGAN menggunakan framework deep learning populer, TensorFlow dan Keras, untuk meningkatkan resolusi gambar Anda.

Prasyarat Mengikuti Tutorial SRGAN TensorFlow Keras Ini

Sebelum memulai implementasi, pastikan Anda memiliki pemahaman dan perangkat lunak yang diperlukan agar dapat mengikuti tutorial meningkatkan resolusi gambar dengan SRGAN ini dengan lancar.

Pengetahuan Dasar yang Dibutuhkan

• Pemrograman Python: Familiaritas dengan sintaks dasar Python, struktur data, dan fungsi.
• Konsep Deep Learning: Pemahaman dasar mengenai Convolutional Neural Networks (CNN) dan cara kerja Generative Adversarial Networks (GAN), termasuk peran Generator dan Discriminator.
• TensorFlow dan Keras: Pengalaman awal dalam menggunakan TensorFlow dan Keras untuk membangun dan melatih model deep learning.

Kebutuhan Perangkat Lunak dan Library Python

Pastikan lingkungan pengembangan Anda memiliki perangkat lunak dan library berikut:

• Python: Versi 3.7 atau yang lebih baru sangat direkomendasikan.
• TensorFlow: Framework deep learning utama yang akan kita gunakan. Versi 2.x atau lebih tinggi. (`tensorflow`)
• OpenCV: Library untuk operasi pemrosesan gambar, seperti membaca dan mengubah ukuran gambar. (`opencv-python`)
• Matplotlib: Library untuk visualisasi data dan hasil gambar. (`matplotlib`)
• NumPy: Library fundamental untuk komputasi numerik di Python. (`numpy`)

Menggunakan library Python untuk image enhancement seperti ini akan mempermudah proses pengembangan Python super resolution gambar.

Persiapan Lingkungan Python untuk Tutorial SRGAN

Langkah pertama adalah memastikan semua library yang dibutuhkan telah terinstal di lingkungan Python Anda untuk memulai proyek deep learning pengolahan citra ini.

Instalasi Library Python yang Diperlukan

Anda dapat menginstal library-library tersebut menggunakan `pip`, package installer untuk Python. Buka terminal atau command prompt Anda dan jalankan perintah berikut:

pip install tensorflow opencv-python matplotlib numpy

Sangat disarankan untuk menggunakan lingkungan virtual (seperti `venv` atau `conda`) untuk setiap proyek deep learning pengolahan citra. Ini membantu mengisolasi dependensi proyek dan menghindari konflik antar library.

# Contoh membuat dan mengaktifkan venv (opsional)
python -m venv srgan_env

# Windows
srgan_env\Scripts\activate

# MacOS/Linux
source srgan_env/bin/activate

# Kemudian jalankan perintah pip install di atas

Memahami Arsitektur dan Cara Kerja SRGAN

SRGAN, seperti GAN pada umumnya, terdiri dari dua jaringan neural yang saling 'bersaing': Generator (G) dan Discriminator (D). Memahami cara kerja SRGAN adalah kunci sebelum melangkah ke implementasi. Proses ini didasarkan pada permainan minimax antara kedua jaringan ini selama proses pelatihan.

Komponen Generator (G) dalam SRGAN

Tugas utama Generator dalam SRGAN adalah mengambil gambar Low-Resolution (LR) sebagai input dan menghasilkan gambar High-Resolution (HR) yang terlihat serealistis mungkin. Arsitektur Generator SRGAN sering kali didasarkan pada SRResNet, yang menggunakan beberapa blok residual (Residual Blocks) untuk memungkinkan jaringan belajar fitur-fitur kompleks dan mempertahankan informasi penting. Di akhir jaringan, terdapat lapisan upsampling (seperti `Conv2DTranspose` atau metode PixelShuffle yang lebih modern) untuk meningkatkan dimensi spasial gambar ke resolusi target. Penggunaan GAN untuk peningkatan resolusi memungkinkan hasil yang lebih tajam dibandingkan metode berbasis Mean Squared Error (MSE) saja.

Komponen Discriminator (D) dalam SRGAN

Discriminator bertugas sebagai 'kritikus'. Ia dilatih untuk membedakan antara gambar HR asli (yang berasal dari dataset) dan gambar HR 'palsu' yang dihasilkan oleh Generator. Arsitektur Discriminator biasanya adalah Convolutional Neural Network (CNN) standar yang dirancang untuk tugas klasifikasi biner. Outputnya adalah probabilitas bahwa gambar input adalah gambar HR asli.

Mekanisme Adversarial Training SRGAN

Selama proses training model SRGAN TensorFlow, Generator dan Discriminator dilatih secara bergantian:

1. Melatih Discriminator: Discriminator diberi batch campuran gambar HR asli dan gambar HR palsu (hasil Generator). Tujuannya adalah agar Discriminator semakin baik dalam mengklasifikasikan mana yang asli dan mana yang palsu. Bobot Discriminator diperbarui berdasarkan performa klasifikasinya.
2. Melatih Generator: Generator menghasilkan batch gambar HR palsu dari input LR. Gambar-gambar ini kemudian dimasukkan ke Discriminator (yang bobotnya dibekukan sementara). Tujuannya adalah agar Generator 'menipu' Discriminator sehingga mengklasifikasikan gambar palsu sebagai gambar asli. Bobot Generator diperbarui berdasarkan seberapa 'berhasil' ia menipu Discriminator, serta berdasarkan seberapa mirip fitur perseptual gambar hasil dengan gambar asli (menggunakan Perceptual Loss).

Proses adversarial training ini mendorong Generator untuk menghasilkan gambar yang tidak hanya akurat secara piksel tetapi juga memiliki tekstur dan detail yang meyakinkan secara visual, mengatasi keterbatasan gambar resolusi rendah dengan deep learning.

Implementasi SRGAN dengan TensorFlow Keras Langkah demi Langkah

Sekarang, mari kita masuk ke bagian implementasi super resolution GAN menggunakan TensorFlow dan Keras. Bagian ini menyajikan contoh kode Keras untuk setiap langkah penting.

Langkah 1: Mempersiapkan Dataset untuk Super Resolution

Kualitas model SRGAN sangat bergantung pada dataset yang digunakan. Beberapa dataset untuk super resolution yang populer meliputi:

• DIV2K: Dataset berkualitas tinggi yang sering digunakan sebagai standar benchmark.
• Set5, Set14, BSD100: Dataset yang lebih kecil, sering digunakan untuk evaluasi cepat.
• Flickr2K: Dataset besar lainnya.

Anda perlu mengunduh salah satu dataset ini (misalnya, DIV2K). Biasanya, dataset ini hanya menyediakan gambar HR. Anda perlu membuat pasangan gambar LR-HR sendiri dalam langkah preprocessing. Susun gambar HR dalam satu folder (misalnya, `dataset/HR`).

Langkah 2: Preprocessing Data - Membuat Pasangan Gambar Low-Res dan High-Res

Langkah ini melibatkan pembuatan gambar LR dari gambar HR dan mempersiapkannya untuk dimasukkan ke model. Proses umumnya adalah:

1. Membaca Gambar HR: Gunakan TensorFlow (`tf.io.read_file`, `tf.image.decode_image`) atau OpenCV (`cv2.imread`) untuk membaca gambar HR dari folder dataset.
2. Membuat Gambar LR: Lakukan downsampling pada gambar HR untuk membuat versi LR. Biasanya menggunakan `tf.image.resize` (defaultnya bicubic) atau `cv2.resize` dengan faktor skala tertentu (misal, 4x) dan metode interpolasi seperti `cv2.INTER_CUBIC`.
3. Normalisasi Nilai Piksel: Ubah rentang nilai piksel gambar (biasanya 0-255) ke rentang yang lebih sesuai untuk input jaringan neural, seperti [0, 1] atau [-1, 1].
4. Membuat Data Pipeline: Gunakan `tf.data.Dataset` untuk membuat pipeline data yang efisien. Ini memungkinkan pemuatan dan preprocessing data secara paralel saat model sedang training, menghemat waktu.

Berikut contoh sederhana fungsi preprocessing menggunakan TensorFlow dalam tutorial image processing ini:

import tensorflow as tf
import numpy as np
import os

# Contoh Ukuran Target dan Faktor Downsampling
IMG_WIDTH_HR = 128
IMG_HEIGHT_HR = 128
FACTOR = 4 # Faktor downsampling (e.g., 4x)
IMG_WIDTH_LR = IMG_WIDTH_HR // FACTOR
IMG_HEIGHT_LR = IMG_HEIGHT_HR // FACTOR

def load_and_preprocess_image(image_path):
    # Baca gambar HR
    hr_image = tf.io.read_file(image_path)
    # Decode image, tentukan channel RGB, dan hindari animasi GIF
    hr_image = tf.image.decode_image(hr_image, channels=3, expand_animations=False)
    # Konversi ke float32 dalam rentang [0, 1]
    hr_image = tf.image.convert_image_dtype(hr_image, tf.float32)

    # Random crop jika gambar dataset lebih besar dari ukuran target
    # Ini bertindak sebagai augmentasi data dan memastikan ukuran input konsisten
    hr_image = tf.image.random_crop(hr_image, size=[IMG_HEIGHT_HR, IMG_WIDTH_HR, 3])

    # Buat gambar LR menggunakan tf.image.resize (metode bicubic adalah default)
    lr_image = tf.image.resize(hr_image, [IMG_HEIGHT_LR, IMG_WIDTH_LR], method=tf.image.ResizeMethod.BICUBIC)

    # Normalisasi ke [-1, 1] (alternatif, SRGAN asli bisa menggunakan [0, 1] atau normalisasi VGG)
    # hr_image = (hr_image * 2.0) - 1.0
    # lr_image = (lr_image * 2.0) - 1.0

    return lr_image, hr_image

def create_dataset(hr_image_dir, batch_size):
    # Dapatkan daftar path file gambar HR
    hr_filepaths = tf.data.Dataset.list_files(os.path.join(hr_image_dir, '*'), shuffle=False)
    
    # Buat dataset dari path file
    dataset = hr_filepaths.map(load_and_preprocess_image, num_parallel_calls=tf.data.experimental.AUTOTUNE)
    
    # Acak data
    # Tentukan buffer_size, bisa sejumlah file atau angka besar yang representatif
    dataset = dataset.shuffle(buffer_size=len(list(hr_filepaths)))
    
    # Kelompokkan menjadi batch
    dataset = dataset.batch(batch_size)
    
    # Optimalkan pemuatan data
    dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
    return dataset

# Contoh Penggunaan:
# HR_FOLDER = 'path/to/your/dataset/HR' # Ganti dengan path direktori dataset HR Anda
# BATCH_SIZE = 16 # Ukuran batch, sesuaikan dengan memori GPU
# train_dataset = create_dataset(HR_FOLDER, BATCH_SIZE)

Langkah 3: Mendefinisikan Model Generator SRGAN Menggunakan Keras

Generator mengambil gambar LR dan menghasilkan gambar HR. Arsitekturnya biasanya terdiri dari blok konvolusi awal, beberapa blok residual, dan blok upsampling di akhir. Berikut adalah contoh kode Keras untuk Generator:

from tensorflow.keras.layers import Input, Conv2D, BatchNormalization, PReLU, Add, UpSampling2D, Lambda
from tensorflow.keras.models import Model
import tensorflow as tf # Diperlukan untuk Lambda layer PixelShuffle

def residual_block(x_in):
    """Blok residual seperti yang digunakan di SRGAN."""
    x = Conv2D(64, kernel_size=3, strides=1, padding='same')(x_in)
    x = BatchNormalization()(x)
    x = PReLU(shared_axes=[1, 2])(x)
    x = Conv2D(64, kernel_size=3, strides=1, padding='same')(x)
    x = BatchNormalization()(x)
    x = Add()([x_in, x]) # Skip connection
    return x

def upsample_block(x_in, factor=2):
    """Blok upsampling menggunakan PixelShuffle (Subpixel Convolution)."""
    # Konvolusi untuk meningkatkan jumlah channel
    num_filters = 64 * (factor ** 2)
    x = Conv2D(num_filters, kernel_size=3, padding='same')(x_in)
    # Menggunakan tf.nn.depth_to_space untuk menata ulang piksel dari channel ke spasial
    x = Lambda(lambda x: tf.nn.depth_to_space(x, block_size=factor))(x)
    x = PReLU(shared_axes=[1, 2])(x)
    return x

def build_generator(lr_shape, num_residual_blocks=16, upsample_factor=4):
    """Membangun model Generator SRGAN."""
    lr_input = Input(shape=lr_shape, name="generator_input")

    # Lapisan konvolusi awal
    x = Conv2D(64, kernel_size=9, strides=1, padding='same')(lr_input)
    x = PReLU(shared_axes=[1, 2])(x)
    x_res_start = x # Simpan output untuk koneksi skip global

    # Rangkaian blok residual
    for _ in range(num_residual_blocks):
        x = residual_block(x)

    # Lapisan konvolusi setelah blok residual
    x = Conv2D(64, kernel_size=3, strides=1, padding='same')(x)
    x = BatchNormalization()(x)
    x = Add()([x_res_start, x]) # Koneksi skip global

    # Blok upsampling
    # Jika upsample_factor=4, perlu dua kali upsample 2x
    num_upsamples = int(tf.math.log(float(upsample_factor)) / tf.math.log(2.0))
    for _ in range(num_upsamples):
        x = upsample_block(x, factor=2)

    # Lapisan output
    # Menghasilkan gambar HR dengan 3 channel (RGB)
    # Aktivasi 'tanh' menghasilkan output [-1, 1]
    # Aktivasi 'sigmoid' menghasilkan output [0, 1]
    # Pilih sesuai normalisasi data Anda
    hr_output = Conv2D(3, kernel_size=9, strides=1, padding='same', activation='tanh', name="generator_output")(x)
    # Atau jika normalisasi [0, 1]:
    # hr_output = Conv2D(3, kernel_size=9, strides=1, padding='same', activation='sigmoid', name="generator_output")(x)

    return Model(inputs=lr_input, outputs=hr_output, name="generator")

# Contoh Penggunaan:
# generator = build_generator(lr_shape=(IMG_HEIGHT_LR, IMG_WIDTH_LR, 3), upsample_factor=FACTOR)
# generator.summary()

Langkah 4: Mendefinisikan Model Discriminator Menggunakan Keras

Discriminator adalah CNN yang mengklasifikasikan gambar input sebagai 'nyata' (dari dataset) atau 'palsu' (dari generator). Berikut contoh kode Keras untuk Discriminator:

from tensorflow.keras.layers import Input, Conv2D, BatchNormalization, LeakyReLU, Dense, Flatten
from tensorflow.keras.models import Model

def conv_block(x_in, filters, strides=1, use_batch_norm=True):
    """Blok konvolusi standar untuk Discriminator."""
    x = Conv2D(filters, kernel_size=3, strides=strides, padding='same')(x_in)
    if use_batch_norm:
        x = BatchNormalization()(x)
    x = LeakyReLU(alpha=0.2)(x)
    return x

def build_discriminator(hr_shape):
    """Membangun model Discriminator SRGAN."""
    hr_input = Input(shape=hr_shape, name="discriminator_input")

    # Rangkaian blok konvolusi dengan peningkatan filter dan downsampling (strides=2)
    x = conv_block(hr_input, 64, strides=1, use_batch_norm=False) # Blok pertama tanpa Batch Norm
    x = conv_block(x, 64, strides=2)

    x = conv_block(x, 128, strides=1)
    x = conv_block(x, 128, strides=2)

    x = conv_block(x, 256, strides=1)
    x = conv_block(x, 256, strides=2)

    x = conv_block(x, 512, strides=1)
    x = conv_block(x, 512, strides=2)

    # Lapisan Fully Connected setelah Flatten
    x = Flatten()(x)
    x = Dense(1024)(x)
    x = LeakyReLU(alpha=0.2)(x)
    
    # Lapisan output: satu neuron dengan aktivasi sigmoid untuk probabilitas [0, 1]
    # 0 = Palsu, 1 = Asli
    output = Dense(1, activation='sigmoid', name="discriminator_output")(x)

    return Model(inputs=hr_input, outputs=output, name="discriminator")

# Contoh Penggunaan:
# discriminator = build_discriminator(hr_shape=(IMG_HEIGHT_HR, IMG_WIDTH_HR, 3))
# # Kompilasi Discriminator (biasanya dilakukan terpisah dalam training loop kustom GAN)
# # discriminator.compile(loss='binary_crossentropy', 
# #                       optimizer=tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5),
# #                       metrics=['accuracy'])
# discriminator.summary()

Langkah 5: Mendefinisikan Fungsi Loss untuk Training Model SRGAN

SRGAN menggunakan kombinasi loss yang disebut Perceptual Loss untuk melatih Generator, yang terdiri dari Content Loss dan Adversarial Loss. Pemilihan fungsi loss ini sangat penting dalam training model SRGAN TensorFlow.

• Content Loss: Mengukur perbedaan fitur perseptual antara gambar HR asli dan gambar HR hasil Generator. Biasanya dihitung menggunakan Mean Squared Error (MSE) antara feature map dari lapisan-lapisan tertentu (misalnya, `block5_conv4`) pada jaringan VGG19 yang sudah dilatih (pre-trained). Ini mendorong kesamaan konten dan struktur visual tingkat tinggi.
• Adversarial Loss: Mendorong Generator untuk menghasilkan gambar yang dapat 'menipu' Discriminator. Dihitung menggunakan Binary Cross-Entropy (BCE) berdasarkan output Discriminator untuk gambar palsu, dengan target label 'asli' (1).
• Discriminator Loss: Loss standar BCE untuk tugas klasifikasi biner, melatih Discriminator untuk membedakan gambar asli (target label 1) dan palsu (target label 0).

Berikut contoh implementasi fungsi loss SRGAN (membutuhkan VGG19):

from tensorflow.keras.applications import VGG19
from tensorflow.keras.losses import BinaryCrossentropy, MeanSquaredError
from tensorflow.keras.models import Model
import tensorflow as tf

# Inisialisasi fungsi loss standar
binary_crossentropy = BinaryCrossentropy()
mean_squared_error = MeanSquaredError()

# Membangun model VGG untuk content loss (hanya perlu sekali)
def build_vgg_content_model(hr_shape):
    """Membangun model VGG19 pre-trained untuk ekstraksi fitur content loss."""
    vgg = VGG19(weights="imagenet", include_top=False, input_shape=hr_shape)
    # Pilih layer untuk content loss (contoh: block5_conv4)
    # Nama layer bisa bervariasi antar versi TensorFlow/Keras. Gunakan vgg.summary() untuk verifikasi.
    try:
        # Coba nama layer umum
        content_layer_name = 'block5_conv4'
        output_layer = vgg.get_layer(content_layer_name).output
    except ValueError:
        print(f"Peringatan: Layer '{content_layer_name}' tidak ditemukan. Mencari alternatif di block 5...")
        # Cari layer konvolusi terakhir di blok 5 sebagai fallback
        output_layer = None
        for layer in reversed(vgg.layers):
            if 'block5_conv' in layer.name:
                 content_layer_name = layer.name
                 output_layer = layer.output
                 print(f"Menggunakan layer: {content_layer_name}")
                 break
        if output_layer is None:
             raise ValueError("Tidak dapat menemukan layer content loss yang cocok di VGG19.")
            
    vgg_content_model = Model(inputs=vgg.input, outputs=output_layer, name="vgg_content_model")
    vgg_content_model.trainable = False # Bekukan bobot VGG
    return vgg_content_model

# Asumsikan hr_shape sudah didefinisikan
# vgg_content_model = build_vgg_content_model((IMG_HEIGHT_HR, IMG_WIDTH_HR, 3))

# Normalisasi input untuk VGG19 (biasanya memerlukan rentang [0, 255] dan format BGR atau preprocessing khusus)
def preprocess_for_vgg(image_tensor):
    # Asumsikan input tensor adalah float32 [0, 1] atau [-1, 1]
    # Konversi ke [0, 255]
    if tf.reduce_min(image_tensor) < 0:
        image_tensor = (image_tensor + 1.0) / 2.0 # Konversi [-1, 1] ke [0, 1]
    image_tensor_255 = image_tensor * 255.0
    # Gunakan fungsi preprocessing bawaan VGG19
    return tf.keras.applications.vgg19.preprocess_input(image_tensor_255)

def content_loss(hr_real, hr_fake):
    """Menghitung content loss berbasis fitur VGG."""
    # Preprocess gambar untuk VGG
    hr_real_vgg = preprocess_for_vgg(hr_real)
    hr_fake_vgg = preprocess_for_vgg(hr_fake)

    # Ekstrak fitur VGG
    real_features = vgg_content_model(hr_real_vgg, training=False)
    fake_features = vgg_content_model(hr_fake_vgg, training=False)

    # Hitung MSE antara fitur
    return mean_squared_error(real_features, fake_features)

def generator_adversarial_loss(fake_output_discriminator):
    """Menghitung adversarial loss untuk Generator."""
    # Generator ingin Discriminator mengira gambar palsu adalah asli (target label=1)
    return binary_crossentropy(tf.ones_like(fake_output_discriminator), fake_output_discriminator)

def discriminator_loss(real_output, fake_output):
    """Menghitung loss untuk Discriminator."""
    # Loss untuk gambar asli (target label=1)
    real_loss = binary_crossentropy(tf.ones_like(real_output), real_output)
    # Loss untuk gambar palsu (target label=0)
    fake_loss = binary_crossentropy(tf.zeros_like(fake_output), fake_output)
    # Total loss adalah jumlah keduanya
    return real_loss + fake_loss

# Bobot untuk kombinasi loss generator (hyperparameter yang bisa di-tuning)
CONTENT_LOSS_FACTOR = 0.006 # Sering disebut beta di paper SRGAN
ADVERSARIAL_LOSS_FACTOR = 1e-3 # Sering disebut alpha atau gamma

def total_generator_loss(hr_real, hr_fake, fake_output_discriminator):
    """Menghitung total perceptual loss untuk Generator."""
    c_loss = content_loss(hr_real, hr_fake)
    adv_loss = generator_adversarial_loss(fake_output_discriminator)
    return CONTENT_LOSS_FACTOR * c_loss + ADVERSARIAL_LOSS_FACTOR * adv_loss

Langkah 6: Implementasi Training Loop untuk SRGAN di TensorFlow

Training GAN biasanya memerlukan custom training loop karena Generator dan Discriminator perlu diperbarui secara terpisah dan bergantian. Ini adalah inti dari proses training model SRGAN TensorFlow.

import time
import os
from tensorflow.keras.optimizers import Adam
import tensorflow as tf

# Inisialisasi optimizer (learning rate umum untuk SRGAN)
gen_optimizer = Adam(learning_rate=1e-4)
disc_optimizer = Adam(learning_rate=1e-4)

# Pastikan model Generator, Discriminator, dan VGG sudah dibuat
# generator = build_generator(...)
# discriminator = build_discriminator(...)
# vgg_content_model = build_vgg_content_model(...)

# Setup Checkpoint untuk menyimpan dan memulihkan model
checkpoint_dir = './training_checkpoints_srgan'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
checkpoint = tf.train.Checkpoint(generator_optimizer=gen_optimizer,
                                 discriminator_optimizer=disc_optimizer,
                                 generator=generator,
                                 discriminator=discriminator)

@tf.function # Kompilasi ke graph TensorFlow untuk performa lebih cepat
def train_step(lr_images, hr_images):
    """Melakukan satu langkah training untuk Generator dan Discriminator."""
    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        # 1. Generate gambar HR palsu menggunakan Generator
        generated_hr_images = generator(lr_images, training=True)

        # 2. Dapatkan output Discriminator untuk gambar asli dan palsu
        real_output = discriminator(hr_images, training=True)
        fake_output = discriminator(generated_hr_images, training=True)

        # 3. Hitung semua komponen loss
        gen_adv_loss = generator_adversarial_loss(fake_output)
        gen_content_loss = content_loss(hr_images, generated_hr_images)
        gen_total_loss = ADVERSARIAL_LOSS_FACTOR * gen_adv_loss + CONTENT_LOSS_FACTOR * gen_content_loss
        
        disc_loss = discriminator_loss(real_output, fake_output)

    # 4. Hitung gradient untuk kedua model
    gradients_of_generator = gen_tape.gradient(gen_total_loss, generator.trainable_variables)
    gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)

    # 5. Terapkan gradient untuk memperbarui bobot model
    gen_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
    disc_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

    return gen_total_loss, disc_loss, gen_content_loss, gen_adv_loss

# Fungsi training utama
def train(dataset, epochs):
    """Loop training utama untuk SRGAN."""
    if not os.path.exists(checkpoint_dir):
        os.makedirs(checkpoint_dir)
        
    # Coba pulihkan checkpoint terakhir jika ada
    latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
    if latest_checkpoint:
        print(f"Memulihkan checkpoint dari {latest_checkpoint}")
        checkpoint.restore(latest_checkpoint)
    else:
        print("Memulai training dari awal.")

    for epoch in range(epochs):
        start_time = time.time()
        total_gen_loss, total_disc_loss = 0, 0
        total_gen_content_loss, total_gen_adv_loss = 0, 0
        num_batches = 0

        print(f"\nMemulai Epoch {epoch + 1}")
        for batch_idx, (lr_batch, hr_batch) in enumerate(dataset):
            # Lakukan satu langkah training
            g_loss, d_loss, g_content, g_adv = train_step(lr_batch, hr_batch)
            
            # Akumulasi loss
            total_gen_loss += g_loss
            total_disc_loss += d_loss
            total_gen_content_loss += g_content
            total_gen_adv_loss += g_adv
            num_batches += 1

            # Log progress setiap beberapa batch
            if batch_idx % 100 == 0:
                print(f'> Epoch {epoch+1}, Batch {batch_idx}/{tf.data.experimental.cardinality(dataset).numpy()}, ' 
                      f'Gen Loss: {g_loss:.4f} (Content: {CONTENT_LOSS_FACTOR*g_content:.4f}, Adv: {ADVERSARIAL_LOSS_FACTOR*g_adv:.4f}), ' 
                      f'Disc Loss: {d_loss:.4f}')

        # Hitung rata-rata loss untuk epoch ini
        avg_gen_loss = total_gen_loss / num_batches
        avg_disc_loss = total_disc_loss / num_batches
        avg_gen_content_loss = total_gen_content_loss / num_batches
        avg_gen_adv_loss = total_gen_adv_loss / num_batches
        epoch_time = time.time() - start_time

        print(f'Akhir Epoch {epoch + 1} | Waktu: {epoch_time:.2f}s | ' 
              f'Avg Gen Loss: {avg_gen_loss:.4f} (Content: {CONTENT_LOSS_FACTOR*avg_gen_content_loss:.4f}, Adv: {ADVERSARIAL_LOSS_FACTOR*avg_gen_adv_loss:.4f}) | '
              f'Avg Disc Loss: {avg_disc_loss:.4f}')

        # Simpan checkpoint setiap beberapa epoch (misal, setiap 5 epoch)
        if (epoch + 1) % 5 == 0:
            save_path = checkpoint.save(file_prefix=checkpoint_prefix)
            print(f'Checkpoint disimpan untuk epoch {epoch + 1} di {save_path}')

# Contoh memulai training (memerlukan dataset yang sudah dibuat)
# EPOCHS = 100 # Jumlah epoch (bisa sangat lama, perlu GPU kuat)
# train(train_dataset, EPOCHS)

Implementasi super resolution GAN ini memerlukan sumber daya komputasi yang signifikan, terutama GPU, untuk training yang efisien. Proses training bisa memakan waktu berjam-jam atau bahkan berhari-hari tergantung pada ukuran dataset, arsitektur model, dan kekuatan hardware.

Mengevaluasi Kinerja Model SRGAN dan Visualisasi Hasil

Setelah model dilatih, langkah selanjutnya adalah mengevaluasi kinerjanya dalam meningkatkan resolusi gambar dan memvisualisasikan hasilnya.

Menguji Model SRGAN pada Gambar Baru

Untuk menguji model, muat bobot yang tersimpan dari checkpoint terakhir atau terbaik. Kemudian, ambil gambar LR baru (yang tidak ada dalam dataset training), lakukan preprocessing yang sama, dan gunakan metode `generator.predict()` untuk menghasilkan versi HR.

import time
import tensorflow as tf
import cv2 # OpenCV untuk membaca dan menulis gambar
import numpy as np
import os

# Asumsikan 'generator' sudah dibuat (build_generator)
# Pastikan ukurannya sesuai dengan yang digunakan saat training
# generator = build_generator(lr_shape=(None, None, 3), ...) # Gunakan None jika ingin fleksibel

# Muat bobot dari checkpoint terakhir
# checkpoint_dir = './training_checkpoints_srgan'
# checkpoint = tf.train.Checkpoint(generator=generator) # Hanya perlu generator untuk inferensi
# latest_ckpt = tf.train.latest_checkpoint(checkpoint_dir)
# if latest_ckpt:
#    status = checkpoint.restore(latest_ckpt)
#    status.expect_partial() # Mencegah error jika optimizer tidak dimuat
#    print(f"Bobot generator dipulihkan dari {latest_ckpt}")
# else:
#    print("Peringatan: Tidak ada checkpoint ditemukan, menggunakan generator yang belum dilatih.")

# Fungsi untuk preprocessing gambar LR tunggal saat inferensi
def preprocess_lr_image_for_inference(lr_image_path):
    lr_img = tf.io.read_file(lr_image_path)
    lr_img = tf.image.decode_image(lr_img, channels=3, expand_animations=False)
    lr_img = tf.image.convert_image_dtype(lr_img, tf.float32) # Normalisasi [0, 1]
    # Jika Anda normalisasi ke [-1, 1] saat training, lakukan di sini juga:
    # lr_img = (lr_img * 2.0) - 1.0
    return tf.expand_dims(lr_img, axis=0) # Tambah dimensi batch

# Fungsi untuk inferensi dan post-processing
def super_resolve_image(generator_model, lr_image_path, output_path):
    # Preprocess gambar LR
    lr_img_batch = preprocess_lr_image_for_inference(lr_image_path)
    print(f"Input LR shape: {lr_img_batch.shape}")

    # Generate gambar HR
    start = time.time()
    sr_img_batch = generator_model.predict(lr_img_batch)
    inference_time = time.time() - start
    print(f"Waktu inferensi: {inference_time:.4f}s")
    print(f"Output SR shape: {sr_img_batch.shape}")

    # Post-process: kembalikan ke format gambar standar
    sr_img = tf.squeeze(sr_img_batch, axis=0) # Hapus dimensi batch
    # Jika output generator [-1, 1], kembalikan ke [0, 1]
    # sr_img = (sr_img + 1.0) / 2.0
    sr_img = tf.clip_by_value(sr_img, 0.0, 1.0) # Pastikan nilai tetap di [0, 1]
    
    # Konversi ke [0, 255] uint8
    sr_img_uint8 = tf.image.convert_image_dtype(sr_img, tf.uint8).numpy()

    # Simpan gambar hasil (OpenCV menggunakan BGR by default)
    cv2.imwrite(output_path, cv2.cvtColor(sr_img_uint8, cv2.COLOR_RGB2BGR))
    print(f"Gambar Super Resolved disimpan di: {output_path}")
    return sr_img_uint8 # Kembalikan array NumPy untuk visualisasi

# Contoh Penggunaan:
# LR_TEST_IMAGE = 'path/to/your/low_res_test_image.png'
# OUTPUT_SR_IMAGE = 'output_super_resolved.png'
# output_sr_image_np = super_resolve_image(generator, LR_TEST_IMAGE, OUTPUT_SR_IMAGE)

Metrik Evaluasi Kuantitatif: PSNR dan SSIM

Dua metrik kuantitatif yang paling umum digunakan untuk mengevaluasi kualitas gambar hasil super resolution adalah PSNR dan SSIM. Ini membantu dalam perbandingan metode super resolution secara objektif.

• PSNR (Peak Signal-to-Noise Ratio): Mengukur rasio antara kekuatan maksimum sinyal (gambar asli HR) dan kekuatan noise yang mengganggu (perbedaan antara gambar asli HR dan hasil SR). Nilai PSNR yang lebih tinggi (dalam dB) umumnya menunjukkan kualitas rekonstruksi piksel-ke-piksel yang lebih baik. Namun, PSNR tidak selalu berkorelasi baik dengan persepsi kualitas visual manusia.
• SSIM (Structural Similarity Index Measure): Mengukur kesamaan struktural antara dua gambar, dengan mempertimbangkan luminans, kontras, dan struktur. Nilai SSIM berkisar antara -1 hingga 1, dengan 1 menunjukkan kesamaan struktural sempurna. SSIM sering dianggap lebih mencerminkan persepsi kualitas visual manusia dibandingkan PSNR.

Anda dapat menghitung PSNR dan SSIM menggunakan `tf.image`:

import tensorflow as tf
import cv2
import numpy as np

# Fungsi untuk menghitung metrik
def calculate_metrics(hr_real_path, sr_generated_np_uint8):
    # Muat gambar ground truth HR
    hr_real_img = cv2.imread(hr_real_path)
    if hr_real_img is None:
        print(f"Error: Tidak dapat memuat gambar HR asli dari {hr_real_path}")
        return None, None
    hr_real_img = cv2.cvtColor(hr_real_img, cv2.COLOR_BGR2RGB)
    
    # Pastikan tipe data dan rentang konsisten (float32, [0, 1])
    hr_real_img_float = hr_real_img.astype(np.float32) / 255.0
    sr_generated_float = sr_generated_np_uint8.astype(np.float32) / 255.0
    
    # Pastikan ukuran gambar sama (crop ground truth jika perlu)
    target_h, target_w = sr_generated_float.shape[:2]
    hr_real_img_float = hr_real_img_float[:target_h, :target_w, :] 
    
    # Konversi ke tensor TensorFlow
    hr_real_tensor = tf.convert_to_tensor(hr_real_img_float, dtype=tf.float32)
    sr_generated_tensor = tf.convert_to_tensor(sr_generated_float, dtype=tf.float32)

    # Hitung metrik (max_val=1.0 karena gambar dinormalisasi ke [0, 1])
    psnr_value = tf.image.psnr(hr_real_tensor, sr_generated_tensor, max_val=1.0)
    ssim_value = tf.image.ssim(hr_real_tensor, sr_generated_tensor, max_val=1.0)

    return psnr_value.numpy(), ssim_value.numpy()

# Contoh Penggunaan:
# HR_REAL_IMAGE = 'path/to/your/high_res_ground_truth.png'
# psnr, ssim = calculate_metrics(HR_REAL_IMAGE, output_sr_image_np)
# if psnr is not None and ssim is not None:
#    print(f"Evaluasi terhadap {os.path.basename(HR_REAL_IMAGE)}:")
#    print(f"  PSNR: {psnr:.4f} dB")
#    print(f"  SSIM: {ssim:.4f}")

Metrik ini berguna untuk membandingkan performa model secara objektif, terutama saat melakukan eksperimen dengan arsitektur atau parameter training yang berbeda dalam upaya memperbaiki kualitas gambar AI Python.

Visualisasi Hasil: Membandingkan Kualitas Gambar

Evaluasi kuantitatif penting, tetapi inspeksi visual seringkali merupakan cara terbaik untuk menilai kualitas fotorealistik yang dihasilkan SRGAN. Gunakan Matplotlib untuk menampilkan perbandingan berdampingan:

1. Gambar LR asli (input).
2. Gambar hasil upscaling standar (misalnya, menggunakan interpolasi Bicubic `cv2.resize`).
3. Gambar HR hasil SRGAN.
4. Gambar HR asli (ground truth, jika tersedia).

Perbandingan ini secara jelas menunjukkan keunggulan SRGAN dalam merekonstruksi detail halus dan tekstur yang hilang pada metode interpolasi sederhana.

import matplotlib.pyplot as plt
import cv2
import os

# Asumsikan FACTOR sudah didefinisikan (misal, 4)
# FACTOR = 4

def visualize_comparison(lr_img_path, sr_img_np_uint8, hr_real_path=None, factor=FACTOR):
    """Menampilkan perbandingan gambar LR, Bicubic, SRGAN, dan HR Asli."""
    lr_img = cv2.imread(lr_img_path)
    if lr_img is None:
        print(f"Error: Tidak dapat memuat gambar LR dari {lr_img_path}")
        return
    lr_img_rgb = cv2.cvtColor(lr_img, cv2.COLOR_BGR2RGB)

    # Buat versi Bicubic untuk perbandingan
    h, w = lr_img.shape[:2]
    bicubic_img = cv2.resize(lr_img_rgb, (w * factor, h * factor), interpolation=cv2.INTER_CUBIC)

    # Pastikan gambar SRGAN dalam format RGB (jika input dari array NumPy hasil fungsi sebelumnya)
    sr_img_rgb = sr_img_np_uint8 

    # Tentukan jumlah plot
    titles = ['Input Low-Res', f'Bicubic Upscaling ({factor}x)', f'SRGAN Output ({factor}x)']
    images = [lr_img_rgb, bicubic_img, sr_img_rgb]

    # Tambahkan gambar HR asli jika path diberikan
    if hr_real_path and os.path.exists(hr_real_path):
        hr_real_img = cv2.imread(hr_real_path)
        hr_real_img_rgb = cv2.cvtColor(hr_real_img, cv2.COLOR_BGR2RGB)
         # Crop HR asli agar ukurannya sama persis dengan output SR untuk perbandingan visual yang adil
        target_h, target_w = sr_img_rgb.shape[:2]
        hr_real_img_rgb = hr_real_img_rgb[:target_h, :target_w, :]
        titles.append('Ground Truth High-Res')
        images.append(hr_real_img_rgb)
    
    num_plots = len(images)
    fig, axes = plt.subplots(1, num_plots, figsize=(5 * num_plots, 5))
    
    # Jika hanya satu plot, axes bukan array
    if num_plots == 1:
        axes = [axes]
        
    for i, ax in enumerate(axes):
        ax.imshow(images[i])
        ax.set_title(titles[i])
        ax.axis('off')

    plt.tight_layout()
    plt.show()

# Contoh Penggunaan:
# LR_TEST_IMAGE = 'path/to/your/low_res_test_image.png'
# HR_REAL_IMAGE = 'path/to/your/high_res_ground_truth.png' # Opsional
# output_sr_image_np = ... # Hasil dari fungsi super_resolve_image
# visualize_comparison(LR_TEST_IMAGE, output_sr_image_np, HR_REAL_IMAGE, factor=FACTOR)

Visualisasi hasil SRGAN ini akan menyoroti perbedaan kualitas dibandingkan metode super resolution lainnya, menunjukkan efektivitas implementasi super resolution GAN ini.

Kesimpulan dan Langkah Berikutnya dalam Python Super Resolution Gambar

Dalam tutorial SRGAN TensorFlow Keras ini, kita telah membahas langkah-langkah detail untuk mengimplementasikan Super-Resolution Generative Adversarial Network (SRGAN) menggunakan TensorFlow dan Keras. Mulai dari persiapan lingkungan, memahami cara kerja SRGAN, preprocessing data, mendefinisikan model dan fungsi loss, hingga melatih dan mengevaluasi model. Anda telah melihat bagaimana SRGAN dapat secara signifikan meningkatkan resolusi gambar, menghasilkan output yang jauh lebih tajam dan fotorealistik dibandingkan metode interpolasi tradisional.

Langkah selanjutnya yang dapat Anda jelajahi dalam bidang Python super resolution gambar meliputi:

• Fine-tuning: Melakukan fine-tuning pada model yang telah dilatih pada dataset spesifik Anda untuk meningkatkan performa pada jenis gambar tertentu.
• Eksperimen Dataset: Mencoba melatih model pada dataset yang berbeda atau lebih besar, atau dataset yang lebih spesifik untuk domain aplikasi Anda.
• Arsitektur Lanjutan: Menjelajahi varian GAN untuk peningkatan resolusi yang lebih baru dan canggih seperti ESRGAN (Enhanced SRGAN) atau Real-ESRGAN untuk hasil yang mungkin lebih baik pada gambar dunia nyata.
• Optimasi Inferensi: Mengoptimalkan kecepatan inferensi model menggunakan teknik seperti pruning, kuantisasi, atau konversi ke format yang lebih ringan (misalnya, TensorFlow Lite) untuk aplikasi real-time atau pada perangkat dengan sumber daya terbatas.
• Eksplorasi Loss Function: Bereksperimen dengan variasi perceptual loss atau menambahkan loss lain (misal, texture loss) untuk mengontrol karakteristik output.

Teknik Python super resolution gambar seperti SRGAN membuka banyak kemungkinan dalam mengatasi keterbatasan gambar resolusi rendah menggunakan deep learning, mulai dari meningkatkan kualitas media hingga membantu analisis dalam berbagai bidang ilmiah dan komersial. Ini adalah contoh kuat bagaimana AI dapat memecahkan masalah kompleks dalam pengolahan citra.

Teknologi seperti SRGAN menunjukkan potensi luar biasa AI dalam pengolahan citra dan berbagai tugas lainnya. Jika bisnis Anda membutuhkan solusi AI yang lebih terintegrasi, baik untuk pemrosesan visual yang kompleks, otomatisasi SEO, pembuatan konten, atau pengembangan platform kustom (web & mobile), platform seperti Kirim.ai menyediakan serangkaian alat AI canggih dan layanan pengembangan end-to-end. Kami membantu bisnis memanfaatkan kekuatan AI untuk mengotomatiskan tugas, meningkatkan efisiensi, dan mendorong pertumbuhan. Pelajari lebih lanjut untuk melihat bagaimana solusi AI kami dapat disesuaikan dengan kebutuhan spesifik bisnis Anda.