Nama : Febyanti Anggraini

Kelas : 4PA11
NPM : 10520391
Tugas : GAN

Generative Adversarial Networks (GANs) adalah sebuah jenis arsitektur jaringan saraf
tiruan yang pertama kali diperkenalkan oleh Ian Goodfellow dan rekan-rekannya pada tahun
2014. GANs memiliki dua komponen utama: generator dan discriminator. Ide dasar di balik
GANs adalah melatih generator untuk menghasilkan data yang sangat mirip dengan data
nyata, sementara discriminator berusaha untuk membedakan antara data yang dihasilkan oleh
generator dengan data nyata. Keduanya beroperasi dalam sebuah permainan adversarial, di
mana generator berusaha untuk menjadi semakin baik dalam menghasilkan data palsu
sementara discriminator berusaha untuk menjadi semakin baik dalam membedakan antara
data palsu dan data nyata.

 Generator: Komponen ini bertugas untuk membuat data palsu. Generator menerima
input dalam bentuk angka acak (misalnya, vektor Gaussian) dan mengubahnya
menjadi data yang mirip dengan data asli.
 Discriminator: Komponen ini bertugas untuk membedakan antara data palsu yang
dihasilkan oleh generator dan data nyata. Discriminator berusaha untuk memberikan
skor tinggi untuk data asli dan skor rendah untuk data palsu.
 Pelatihan: Proses pelatihan GAN terjadi melalui permainan adversarial. Generator dan
discriminator dilatih secara bersamaan. Generator berusaha untuk memproduksi data
yang lebih baik sehingga discriminator semakin sulit membedakannya. Sebaliknya,
discriminator berusaha untuk menjadi semakin baik dalam membedakan data palsu
dari data nyata.
 Keseimbangan: Pelatihan GAN berlangsung sampai mencapai keseimbangan di mana
generator menghasilkan data yang sangat mirip dengan data nyata, dan discriminator
kesulitan membedakannya.
 Aplikasi: GANs telah digunakan dalam berbagai aplikasi, termasuk penghasilan
gambar realistik, peningkatan resolusi gambar, generasi teks, pembelajaran transfer,
pemadanan gambar, dan banyak lagi.
 Tantangan: GANs memiliki beberapa tantangan, termasuk masalah pelatihan yang
tidak stabil, mode collapse (generator hanya menghasilkan variasi terbatas), dan
 masalah etika terkait dengan penggunaan GANs untuk manipulasi gambar dan
pembuatan deepfake.

Contoh Implementasi: Generasi Gambar Wajah

Salah satu contoh penerapan GAN adalah untuk menghasilkan gambar-gambar
wajah manusia yang realistis. Dalam implementasi ini, generator mencoba
menghasilkan gambar-gambar wajah manusia yang mirip dengan data latih, sementara
discriminator berusaha membedakan antara gambar-gambar palsu dan gambar-gambar
asli.

Contoh Implementasi: Generasi Tulisan Tangan

GAN juga dapat digunakan untuk menghasilkan tulisan tangan yang mirip
dengan tulisan manusia. Generator akan mencoba menghasilkan gambar-gambar
tulisan tangan, sementara discriminator akan mencoba untuk membedakan antara
tulisan palsu dan tulisan nyata.

Contoh implementasi dari algoritma GAN dapat ditemukan dalam berbagai bahasa
pemrograman dan kerangka kerja. Salah satu contoh implementasi yang terkenal adalah
menggunakan Python dengan kerangka kerja TensorFlow atau PyTorch. Berikut ini
adalah contoh implementasi GAN menggunakan TensorFlow:

import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Reshape
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
import numpy as np
import matplotlib.pyplot as plt

# Generator
generator = Sequential([
Dense(128, input_shape=(100,), activation='relu'),
Dense(784, activation='sigmoid'),
Reshape((28, 28))
])
# Discriminator
discriminator = Sequential([
Flatten(input_shape=(28, 28)),
Dense(128, activation='relu'),
Dense(1, activation='sigmoid')
])

# Compile discriminator
discriminator.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5),
metrics=['accuracy'])

# Combined GAN model

discriminator.trainable = False
gan_input = tf.keras.layers.Input(shape=(100,))
x = generator(gan_input)
gan_output = discriminator(x)
gan = tf.keras.models.Model(gan_input, gan_output)
gan.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5))

# Load MNIST dataset

(X_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
X_train = X_train / 127.5 - 1.0
X_train = np.expand_dims(X_train, axis=3)

# Training loop
batch_size = 64
epochs = 10000

for epoch in range(epochs):

noise = np.random.normal(0, 1, (batch_size, 100))
generated_images = generator.predict(noise)
real_images = X_train[np.random.randint(0, X_train.shape[0], batch_size)]
labels_real = np.ones((batch_size, 1))
labels_fake = np.zeros((batch_size, 1))

d_loss_real = discriminator.train_on_batch(real_images, labels_real)

d_loss_fake = discriminator.train_on_batch(generated_images, labels_fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

noise = np.random.normal(0, 1, (batch_size, 100))

labels_gan = np.ones((batch_size, 1))
g_loss = gan.train_on_batch(noise, labels_gan)

if epoch % 100 == 0:
print(f"Epoch: {epoch}, D Loss: {d_loss[0]}, G Loss: {g_loss}")

# Save generated images

if epoch % 1000 == 0:
generated_images = generated_images * 0.5 + 0.5 # Rescale to [0, 1]
fig, axs = plt.subplots(5, 5)
count = 0
for i in range(5):
for j in range(5):
axs[i, j].imshow(generated_images[count], cmap='gray')
axs[i, j].axis('off')
count += 1
plt.show()
Referensi :

Zhang, H., Xu, T., Li, H., Zhang, S., Wang, X., Huang, X., & Metaxas, D. N. (2017).
StackGAN: Text to photo-realistic image synthesis with stacked generative adversarial
networks. In Proceedings of the IEEE international conference on computer vision (pp.
5907-5915).

Roy, A., & Todorovic, S. (2017). Combining generative models and fisher vectors for
handwritten document image retrieval. In Proceedings of the IEEE conference on
computer vision and pattern recognition (CVPR) (pp. 1977-1986).