Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

LAPORAN PRAKTIKUM MINGGU KE-4

” Training CiFar GAN”

Training sebuah GAN (Generative Adversarial Network) pada dataset CIFAR-10

adalah proses yang melibatkan dua model utama: generator dan discriminator. GAN
bertujuan untuk menghasilkan data baru yang terlihat seperti data asli yang ada dalam dataset
CIFAR-10, yang terdiri dari gambar-gambar berukuran 32x32 pixel yang dikelompokkan ke
dalam 10 kelas yang berbeda.

1. Importing Python Packages for GAN

Kode di atas adalah impor Python packages dan library yang Kita butuhkan
untuk memulai pelatihan GAN pada dataset CIFAR-10 menggunakan Keras dan
TensorFlow. Mari kita jelaskan masing-masing bagian dari kode tersebut dalam tahap
pertama pelatihan GAN:

a. Import Packages:

• from keras.datasets import cifar10, mnist: Ini mengimpor dataset CIFAR-10

yang akan digunakan dalam pelatihan. Namun, kode ini juga mengimpor
dataset MNIST, yang seharusnya tidak diperlukan jika tujuan kita adalah
melatih GAN pada dataset CIFAR-10.

• from keras.models import Sequential: Ini mengimpor class Sequential yang

digunakan untuk membuat model jaringan saraf tiruan berurutan.

• from keras.layers import ...: Ini mengimpor berbagai jenis lapisan (layers)
yang akan digunakan dalam model GAN, seperti Reshape, Dense, Flatten,
Conv2D, Conv2DTranspose, Dropout, dan LeakyReLU.

• from tensorflow.keras.optimizers import Adam: Ini mengimpor optimizer

Adam yang akan digunakan untuk mengoptimalkan model GAN.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

• import numpy as np: Ini mengimpor library NumPy yang digunakan untuk
manipulasi data.

b. Membuat Direktori:

• !mkdir generated_images: Ini adalah perintah shell yang digunakan untuk

membuat direktori baru bernama "generated_images." Direktori ini biasanya
digunakan untuk menyimpan gambar-gambar yang dihasilkan oleh generator
selama pelatihan GAN.

Kode ini adalah langkah awal dalam mengimpor semua library yang
diperlukan dan menyiapkan proyek Kita untuk melatih GAN pada dataset CIFAR-
10.

2. Parameters for Neural Networks & Data

Kode di atas menginisialisasi beberapa parameter yang akan digunakan dalam tahap
selanjutnya dalam pelatihan GAN pada dataset CIFAR-10. Mari kita jelaskan masing-
masing parameter tersebut:

a. img_width dan img_height:

Ini adalah lebar dan tinggi gambar dalam dataset CIFAR-10. Gambar CIFAR-
10 memiliki ukuran 32x32 piksel, dan parameter ini menentukan dimensi gambar
yang akan digunakan dalam model GAN.

b. channels:
Ini adalah jumlah saluran warna dalam gambar. Dalam kasus dataset CIFAR-
10, gambar memiliki 3 saluran warna (merah, hijau, dan biru), sehingga channels
diatur ke 3.

c. img_shape:
Ini adalah tuple yang menggambarkan dimensi gambar dalam format (lebar,
tinggi, saluran). Dalam konteks CIFAR-10, img_shape diatur ke (32, 32, 3).

d. latent_dim:
Ini adalah dimensi vektor noise yang akan digunakan sebagai input untuk
generator. latent_dim menentukan seberapa besar kompleksitas model generator
dan berapa banyak informasi noise yang akan digunakan untuk menghasilkan
gambar-gambar palsu.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

e. adam:
Ini adalah optimizer yang digunakan selama pelatihan. Adam adalah optimizer
yang populer dalam deep learning. Dalam kode di atas, Kita mengatur tingkat
pembelajaran (learning rate) dari Adam ke 0.0002, yang biasanya digunakan
dalam pelatihan GAN.

Setelah menginisialisasi parameter-parameter ini, langkah selanjutnya dalam pelatihan

GAN pada dataset CIFAR-10 adalah:

• Mendefinisikan arsitektur generator dan discriminator.

• Menentukan fungsi objektif (loss functions) yang akan digunakan untuk
melatih generator dan discriminator.
• Mengompilasi model generator dan discriminator menggunakan optimizer
Adam yang sudah diatur.
• Memulai proses pelatihan GAN, di mana generator dan discriminator
diperbarui secara bergantian untuk mencapai keseimbangan.

3. Building Generator

Kode di atas adalah implementasi dari fungsi `build_generator` yang bertujuan

untuk membuat arsitektur generator dalam GAN. Arsitektur generator bertanggung
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

jawab untuk menghasilkan gambar-gambar palsu berdasarkan vektor noise sebagai

input. Mari kita jelaskan kode tersebut dalam tahap selanjutnya dalam pelatihan GAN:

1. `model = Sequential()`: Di sini Kita membuat objek model `Sequential`, yang akan
digunakan untuk mengatur lapisan-lapisan secara berurutan dalam generator.

2. `model.add(Dense(256 * 4 * 4, input_dim=latent_dim)`: Ini adalah lapisan pertama

dari generator, yang merupakan lapisan Dense (fully connected). Lapisan ini
menerima input vektor noise dengan dimensi `latent_dim` (yang telah diatur
sebelumnya). Ini akan mengubah vektor noise menjadi representasi awal dengan
dimensi 256 * 4 * 4. Dengan ini, Kita mulai dengan representasi awal dan akan
mengembangkannya menjadi gambar.

3. `model.add(LeakyReLU(alpha=0.2)`: kita menambahkan aktivasi Leaky ReLU

pada lapisan ini. Ini adalah fungsi aktivasi yang umum digunakan dalam GAN untuk
mencegah masalah gradien menghilang (vanishing gradient) dan memungkinkan
pembelajaran yang lebih baik.

4. `model.add(Reshape((4, 4, 256))`: Ini adalah lapisan Reshape yang akan mengubah

representasi linear (hasil dari lapisan Dense sebelumnya) menjadi representasi
berbentuk tensor (4, 4, 256).

5. Kita kemudian menambahkan beberapa lapisan Conv2DTranspose, yang berfungsi

untuk mengembangkan representasi tensor tersebut menjadi gambar yang semakin
besar. Lapisan-lapisan ini memiliki aktivasi LeakyReLU juga.

6. `model.add(Conv2D(3, (3,3), activation='tanh', padding='same')`: Lapisan terakhir

adalah lapisan Conv2D yang akan menghasilkan gambar output. Ini menggunakan
fungsi aktivasi tangen hiperbolik (tanh) untuk menghasilkan piksel gambar pada
rentang [-1, 1] yang sesuai dengan format gambar yang sesuai dengan CIFAR-10.

7. `model.summary()`: Ini digunakan untuk mencetak ringkasan arsitektur generator,

termasuk jumlah parameter yang dapat disesuaikan.

8. `generator = build_generator()`: Di akhir, Kita memanggil fungsi `build_generator`

untuk membuat model generator dan menyimpannya dalam variabel `generator`.

Setelah menginisialisasi generator ini, langkah selanjutnya dalam pelatihan GAN

adalah:

- Membangun arsitektur discriminator.

- Menentukan fungsi objektif (loss functions) yang akan digunakan untuk pelatihan
generator dan discriminator.
- Mengompilasi model generator dan discriminator.
- Memulai proses pelatihan GAN dengan menggabungkan generator dan
discriminator untuk mencapai keseimbangan antara keduanya.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

4. Building Discriminator

Kode di atas adalah implementasi dari fungsi `build_discriminator` yang bertujuan

untuk membuat arsitektur discriminator dalam GAN. Arsitektur discriminator
bertanggung jawab untuk membedakan antara gambar-gambar asli dari dataset dengan
gambar-gambar palsu yang dihasilkan oleh generator.

1. `model = Sequential()`: Membuat objek model `Sequential` yang akan digunakan

untuk mengatur lapisan-lapisan secara berurutan dalam discriminator.

2. `model.add(Conv2D(64, (3,3), padding='same', input_shape=img_shape)`: Lapisan

Conv2D pertama. Lapisan ini menerima gambar input dengan ukuran yang telah
diatur sebelumnya (`img_shape`) dan menggunakan kernel (filter) dengan ukuran (3,
3). Ini menghasilkan 64 map fitur (feature maps) yang digunakan untuk mengekstrak
fitur dari gambar.

3. `model.add(LeakyReLU(alpha=0.2)`: Menambahkan aktivasi Leaky ReLU pada

lapisan ini, yang membantu dalam pembelajaran dengan mencegah gradien
menghilang.

4. Menambahkan beberapa lapisan Conv2D dan aktivasi LeakyReLU tambahan untuk

meningkatkan kemampuan discriminator dalam mengidentifikasi fitur-fitur penting
dalam gambar.

5. `model.add(Flatten())`: Lapisan Flatten mengubah tensor hasil konvolusi menjadi

vektor untuk digunakan pada lapisan Dense selanjutnya.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

6. `model.add(Dropout(0.4)`: Menambahkan lapisan Dropout untuk mencegah

overfitting dalam model discriminator. Ini secara acak "menonaktifkan" sebagian unit
selama pelatihan.

7. `model.add(Dense(1, activation='sigmoid')`: Lapisan terakhir adalah lapisan Dense

dengan satu unit output dan aktivasi sigmoid. Lapisan ini menghasilkan output berupa
probabilitas, di mana nilai yang mendekati 1 menunjukkan bahwa gambar adalah
gambar asli, sementara nilai yang mendekati 0 menunjukkan bahwa gambar adalah
gambar palsu.

8. `model.summary()`: Digunakan untuk mencetak ringkasan arsitektur discriminator,

termasuk jumlah parameter yang dapat disesuaikan.

9. `discriminator = build_discriminator()`: Memanggil fungsi `build_discriminator`

untuk membuat model discriminator dan menyimpannya dalam variabel
`discriminator`.

Setelah menginisialisasi discriminator ini, langkah selanjutnya dalam pelatihan GAN

adalah:

- Membangun arsitektur generator (yang sudah dilakukan sebelumnya).

- Menentukan fungsi objektif (loss functions) yang akan digunakan untuk pelatihan
generator dan discriminator.
- Mengompilasi model generator dan discriminator.
- Memulai proses pelatihan GAN dengan menggabungkan generator dan
discriminator untuk mencapai keseimbangan antara keduanya.

5. Connecting Neural Networks to build GAN

Kode di atas adalah langkah selanjutnya dalam melakukan pelatihan GAN pada
dataset CIFAR-10. Kode ini digunakan untuk menghubungkan generator dan
discriminator menjadi satu model GAN, serta untuk mengatur proses pelatihan GAN.

1. `GAN = Sequential()`: Membuat objek model `Sequential` yang digunakan sebagai

model GAN. Model ini akan terdiri dari generator dan discriminator yang
dihubungkan secara berurutan.

2. `discriminator.trainable = False`: Dengan baris ini, mengatur discriminator menjadi

tidak dapat dilatih (non-trainable) saat melatih model GAN. Ini berarti selama
pelatihan GAN, hanya generator yang akan diperbarui, sementara discriminator akan
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

tetap statis. Hal ini diperlukan karena dalam pelatihan GAN, fokusnya adalah
meningkatkan kualitas gambar yang dihasilkan oleh generator, sehingga "dimatikan"
kemampuan discriminator untuk membedakan gambar.

3. `GAN.add(generator)`: Menambahkan model generator ke dalam model GAN. Ini

berarti output dari generator akan menjadi input untuk discriminator.

4. `GAN.add(discriminator)`: Menambahkan model discriminator ke dalam model

GAN. Ini berarti output dari generator akan melewati discriminator, yang merupakan
langkah kunci dalam pelatihan GAN. GAN mencoba untuk meminimalkan loss pada
output discriminator, yang akan mendorong generator untuk menghasilkan gambar
yang semakin baik.

5. `GAN.compile(loss='binary_crossentropy', optimizer=adam)`: Mengompilasi

model GAN. Loss function yang digunakan adalah binary cross-entropy, yang
mengukur sejauh mana discriminator berhasil membedakan antara gambar asli dan
palsu. Optimizer yang digunakan adalah Adam, yang bertanggung jawab untuk
mengoptimalkan model GAN.

Selanjutnya, langkah selanjutnya dalam pelatihan GAN adalah:

- Memulai proses pelatihan GAN dengan dataset CIFAR-10.

- Selama pelatihan, secara bergantian memperbarui generator dan discriminator untuk
mencapai keseimbangan antara keduanya.
- Proses pelatihan GAN akan berjalan selama beberapa epoch, dan pada setiap epoch,
generator akan berusaha untuk menghasilkan gambar yang semakin mendekati
gambar asli, sementara discriminator akan berusaha untuk semakin baik dalam
membedakan gambar asli dan palsu.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

6. Outputting Images

Kode di atas bertanggung jawab untuk menghasilkan dan menyimpan gambar-

gambar yang dihasilkan oleh generator selama pelatihan GAN. Kode ini digunakan
untuk memvisualisasikan gambar-gambar yang dihasilkan oleh generator seiring
berjalannya waktu selama pelatihan.

1. `save_imgs(epoch)`: Fungsi ini digunakan untuk menghasilkan dan menyimpan

gambar-gambar yang dihasilkan oleh generator selama pelatihan. Argumen `epoch`
tidak digunakan dalam fungsi ini.

2. `r` dan `c`: Variabel ini mengatur jumlah baris (`r`) dan kolom (`c`) gambar yang
akan ditampilkan dalam grid saat gambar-gambar disimpan. Dalam kode ini, ada grid
5x5 yang menampilkan 25 gambar.

3. `noise = np.random.normal(0, 1, (r * c, latent_dim))`: Matriks noise acak dibuat

dengan ukuran `(r * c, latent_dim)`. Noise ini akan digunakan sebagai input untuk
generator untuk menghasilkan gambar-gambar palsu.

4. `gen_imgs = generator.predict(noise)`: Generator digunakan untuk menghasilkan

gambar-gambar palsu berdasarkan vektor noise yang dihasilkan sebelumnya.

5. `global save_name` dan `save_name += 0.00000001`: Ini digunakan untuk

memberikan nama unik pada file gambar yang disimpan. Setiap kali fungsi
`save_imgs` dipanggil, `save_name` akan ditambahkan sejumlah kecil untuk
memastikan nama file yang berbeda.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

6. Rescaling Gambar:
- `gen_imgs = (gen_imgs + 1) / 2.0`: Gambar yang dihasilkan oleh generator
memiliki rentang nilai dari -1 hingga 1. Dalam langkah ini, nilai-nilai ini diubah
menjadi rentang 0 hingga 1 dengan mengambil nilai tengah sebagai 0.5. Ini untuk
memastikan gambar memiliki skala yang benar sebelum disimpan.

7. Membuat Subplot:
- Subplot (grid) dibuat dengan `r` baris dan `c` kolom untuk menampilkan gambar-
gambar yang dihasilkan.

8. Mengisi Subplot dengan Gambar:

- Setiap subplot diisi dengan gambar-gambar yang dihasilkan oleh generator.

9. `fig.savefig("generated_images/%.8f.png" % save_name)`: Gambar-gambar yang

ditampilkan dalam subplot disimpan dalam direktori "generated_images" dengan
nama file yang unik berdasarkan `save_name`.

10. `plt.close()`: Setelah gambar-gambar disimpan, plot ditutup.

Kode ini berfungsi untuk memvisualisasikan dan menyimpan gambar-gambar

yang dihasilkan oleh generator selama pelatihan GAN. Ini memungkinkan untuk
melihat perkembangan generator seiring waktu dan mengidentifikasi sejauh mana
kualitas gambar yang dihasilkan telah meningkat selama pelatihan.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

7. Training GAN

Kode di atas adalah bagian yang melaksanakan proses pelatihan pada GAN
dengan dataset CIFAR-10. Ini merupakan langkah selanjutnya dalam melatih GAN
setelah sebelumnya telah membangun generator dan discriminator, serta
menghubungkannya dalam satu model GAN.

1. `(X_train, _), (_, _) = cifar10.load_data()`: Mengambil dataset CIFAR-10 dari

keras.datasets. Hanya gambar-gambar asli (X_train) yang diperlukan, sedangkan label
diabaikan.

2. `X_train = X_train / 127.5 - 1.`: Mereskalasi data gambar dari rentang [0, 255]
menjadi rentang [-1, 1]. Ini merupakan langkah umum dalam pelatihan GAN untuk
memastikan gambar-gambar memiliki nilai yang sesuai untuk generator dan
discriminator.

3. `bat_per_epo = int(X_train.shape[0] / batch_size)`: Menghitung berapa banyak

batch yang akan diproses pada setiap epoch. Dataset dibagi menjadi batch dengan
ukuran `batch_size`.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

4. `valid = np.ones((batch_size, 1))` dan `fakes = np.zeros((batch_size, 1))`: Membuat

label-label yang akan digunakan untuk melatih discriminator. `valid` digunakan untuk
label gambar asli, dan `fakes` digunakan untuk label gambar palsu.

5. Loop Pelatihan:
- Terdapat loop untuk mengiterasi melalui epoch (`for epoch in range(epochs`) dan
dalam setiap epoch, terdapat loop lagi untuk mengiterasi melalui batch (`for j in
range(bat_per_epo)`).

- Dalam loop batch, dilakukan pengambilan batch acak dari dataset (`idx =
np.random.randint(0, X_train.shape[0], batch_size)`) dan gambar-gambar ini
disimpan dalam variabel `imgs`.

- Gambar-gambar palsu dihasilkan dari generator dengan menggunakan vektor noise

acak (`noise = np.random.normal(0, 1, (batch_size, latent_dim))`) dan menjalankan
generator dengan vektor tersebut (`gen_imgs = generator.predict(noise)`).

- Discriminator dilatih:
- `d_loss_real` mengukur loss pada gambar-gambar asli dengan label `valid`.
- `d_loss_fake` mengukur loss pada gambar-gambar palsu dengan label `fakes`.
- `d_loss` adalah rata-rata loss antara gambar asli dan gambar palsu, dan ini
digunakan untuk mengoptimalkan discriminator.

- Vektor noise acak dihasilkan lagi untuk digunakan dalam melatih generator (`noise
= np.random.normal(0, 1, (batch_size, latent_dim)`).

- Generator dilatih dengan menggunakan model GAN. Label yang digunakan adalah
`valid`, yang berarti generator berusaha untuk "membohong" discriminator dengan
menghasilkan gambar-gambar yang semirip mungkin dengan gambar asli.

- Selama pelatihan, loss dari discriminator dan generator dicetak pada setiap iterasi
dalam format tertentu.

- Setelah selesai melatih discriminator dan generator dalam satu epoch, dipanggil
fungsi `save_imgs(epoch)` untuk menyimpan beberapa gambar yang dihasilkan oleh
generator selama pelatihan.

6. Terakhir, di luar loop pelatihan, satu gambar baru dihasilkan dengan generator
menggunakan vektor noise acak dan ditampilkan menggunakan
`plt.imshow(gen_imgs)`. Gambar ini digunakan untuk melihat hasil dari generator
setelah pelatihan.

Kode ini merangkum proses pelatihan GAN pada dataset CIFAR-10, di mana
generator dan discriminator saling berkompetisi untuk meningkatkan kualitas gambar
yang dihasilkan oleh generator seiring berjalannya epoch-epoch pelatihan.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

8. Making GIF

Kode di atas bertujuan untuk membuat sebuah file GIF yang akan
menampilkan perkembangan gambar-gambar yang dihasilkan oleh generator selama
pelatihan GAN. Ini digunakan untuk membuat animasi yang mengilustrasikan
bagaimana kualitas gambar yang dihasilkan oleh generator berubah seiring
berjalannya waktu selama pelatihan.

1. `anim_file = 'dcgan.gif'`: Menentukan nama file GIF yang akan dihasilkan. Nama
file adalah 'dcgan.gif'.

2. `with imageio.get_writer(anim_file, mode='I') as writer:`: Menggunakan pustaka

imageio untuk membuat penulis (writer) GIF. Mode 'I' digunakan untuk menulis mode
gambar berurutan.

3. `filenames = glob.glob('generated_images/*.png')`: Mengumpulkan daftar file

gambar (dalam format PNG) yang telah disimpan sebelumnya selama pelatihan dalam
direktori 'generated_images' menggunakan pustaka `glob`.

4. `filenames = sorted(filenames)`: Mengurutkan daftar nama file gambar secara

berurutan berdasarkan urutan alfanumerik untuk memastikan urutan waktu yang
benar.

5. Loop untuk Menambahkan Gambar ke GIF:

- Menggunakan loop untuk mengiterasi melalui setiap nama file gambar yang telah
diurutkan.
- `image = imageio.imread(filename)`: Membaca gambar dari file yang sedang
diproses.
- `writer.append_data(image)`: Menambahkan gambar tersebut ke file GIF yang
sedang dibuat.

6. Setelah selesai mengiterasi melalui semua file gambar, mengambil gambar terakhir
lagi dan menambahkannya ke GIF. Ini bertujuan untuk memastikan bahwa gambar
terakhir tetap ditampilkan dalam animasi.
 Hafidzurrohman Saifullah_10120486_M4_PRAKTIKUM

Kode ini menghasilkan sebuah file GIF yang akan menampilkan

perkembangan gambar-gambar yang dihasilkan oleh generator selama pelatihan GAN.
Animasi ini dapat membantu Anda memvisualisasikan sejauh mana kualitas gambar
yang dihasilkan telah meningkat selama pelatihan GAN. Setelah eksekusi kode ini,
Anda akan memiliki file 'dcgan.gif' yang berisi animasi dari gambar-gambar tersebut.