Nama : Citra Maulida Permata Mauni

NPM : 10220366

Kelas : 4EA07

Codingan tersebut adalah implementasi dasar dari GAN (Generative

Adversarial Network) untuk menghasilkan gambar-gambar dengan menggunakan
dataset MNIST. Berikut adalah penjelasan dari setiap bagian kode:

1. `from keras.datasets import mnist`: Ini mengimpor dataset MNIST, yang berisi
gambargambar angka tulisan tangan untuk digunakan dalam pelatihan GAN. 2.
`from keras.models import Sequential`: Ini mengimpor modul untuk membuat
model neural network berurutan.
3. `from keras.layers import BatchNormalization, Dense, Reshape, Flatten`:
Ini mengimpor lapisan-lapisan yang akan digunakan dalam model GAN.
`BatchNormalization` digunakan untuk normalisasi batch, `Dense` untuk lapisan
dense (lapisan terhubung penuh), `Reshape` untuk mengubah bentuk data, dan
`Flatten` untuk mengubah gambar menjadi vektor.
4. `from keras.layers.advanced_activations import LeakyReLU`: Ini
mengimpor lapisan aktivasi LeakyReLU, yang digunakan untuk menghindari
masalah gradien yang hilang.
5. `from tensorflow.keras.optimizers import Adam`: Ini mengimpor optimizer
Adam, yang akan digunakan untuk mengoptimalkan model GAN.
6. `import numpy as np`: Ini mengimpor modul NumPy, yang sering
digunakan untuk manipulasi data numerik.
7. `!mkdir generated_images`: Ini adalah perintah untuk membuat direktori
"generated_images" jika belum ada, yang akan digunakan untuk menyimpan
gambar-gambar yang dihasilkan oleh GAN.

Kode ini adalah langkah awal dalam mengatur lingkungan untuk melatih
dan menghasilkan gambar-gambar dengan GAN menggunakan dataset MNIST.
Langkah-langkah selanjutnya akan mencakup pengaturan model generator, model
discriminator, pelatihan GAN, dan pengambilan gambar-gambar hasil generasi.

Codingan ini mengatur beberapa parameter yang akan digunakan dalam

pengembangan model GAN untuk menghasilkan gambar-gambar dari dataset
MNIST. Berikut adalah penjelasan untuk setiap baris kode:

1. `img_width` dan `img_height`: Ini adalah lebar dan tinggi gambar yang akan
dihasilkan.

Dalam konteks dataset MNIST, gambar-gambar ini adalah gambar berukuran

28x28 piksel.
2. `channels`: Ini mengindikasikan jumlah saluran warna dalam gambar. Dalam hal
ini, `channels` disetel ke 1 karena gambar MNIST hanya memiliki satu saluran
warna (gambar grayscale).
3. `img_shape`: Ini adalah tupel yang mendefinisikan bentuk gambar, dengan
informasi lebar, tinggi, dan jumlah saluran warna. Dalam hal ini, `img_shape`
menjadi (28, 28, 1) karena gambar-gambar MNIST adalah gambar 28x28 piksel
dengan satu saluran warna.
4. `latent_dim`: Ini adalah dimensi vektor laten yang akan digunakan sebagai input
untuk generator. Biasanya, Anda dapat memilih berapa banyak dimensi yang
sesuai dengan kebutuhan Anda, misalnya, 100.
5. `adam`: Ini adalah optimizer yang digunakan untuk mengoptimalkan model
GAN selama pelatihan. Optimizer Adam adalah salah satu optimizer yang umum
digunakan dalam deep learning, dan dalam kode ini, diberikan tingkat
pembelajaran (learning rate) sebesar 0.0001.
Pengaturan ini memberikan dasar yang diperlukan untuk mengonfigurasi
model generator, model discriminator, dan proses pelatihan GAN.
 Codingan tersebut adalah implementasi dari model generator dalam jaringan
generatif adversarial (GAN). Model generator bertujuan untuk menghasilkan
gambar-gambar yang realistis dari vektor laten (latent vector) yang diinputkan ke
dalamnya. Berikut adalah penjelasan langkah demi langkah:

1. `model = Sequential()`: Ini membuat model keras berurutan yang akan digunakan
untuk menggabungkan lapisan-lapisan secara berurutan.
2. Ada tiga blok lapisan serupa dalam generator, yang masing-masing terdiri dari:

- `model.add(Dense(256, input_dim=latent_dim))`: Lapisan pertama adalah

lapisan dense (lapisan terhubung penuh) dengan 256 neuron sebagai input.
`latent_dim` adalah dimensi dari vektor laten yang akan menjadi input untuk
generator.
- `model.add(LeakyReLU(alpha=0.2))`: Setelah lapisan dense, ada lapisan
aktivasi LeakyReLU yang memungkinkan aliran gradien bahkan jika nilai inputnya
negatif.
- `model.add(BatchNormalization(momentum=0.8))`: Lalu, ada lapisan
normalisasi batch yang membantu percepatan konvergensi dan mengurangi
masalah gradien yang meledak.
3. Setelah tiga blok lapisan tersebut, ada lapisan output yang berbeda:

- `model.add(Dense(np.prod(img_shape), activation='tanh')`: Ini adalah lapisan

dense dengan keluaran sejumlah neuron yang sama dengan jumlah piksel dalam
gambar yang ingin digenerate (diatur oleh `img_shape`). Aktivasi 'tanh' digunakan
untuk menghasilkan angka antara -1 dan 1, yang cocok untuk gambar dengan piksel
yang dinormalisasi antara 0 dan 1.

4. `model.add(Reshape(img_shape))`: Ini menambahkan lapisan reshaping

untuk mengubah keluaran dari lapisan sebelumnya menjadi bentuk gambar yang
diinginkan sesuai dengan `img_shape`.
5. `model.summary()`: Ini mencetak ringkasan model yang akan menampilkan
detail tentang jumlah parameter di setiap lapisan dan dimensi keluaran.
 Akhirnya, model generator yang telah dibangun disimpan dalam variabel
`generator` dan dapat digunakan untuk menghasilkan gambar-gambar sintetis dari
vektor laten. Model ini biasanya akan digunakan bersama dengan model
discriminator dalam GAN untuk melatih keduanya dalam sebuah proses yang
bersifat bersaing.

Codingan tersebut adalah implementasi dari model discriminator dalam

jaringan generatif adversarial (GAN). Model discriminator bertujuan untuk
membedakan antara gambar-gambar yang dihasilkan oleh generator (palsu) dan
gambar-gambar asli dari dataset (nyata). Berikut adalah penjelasan langkah demi
langkah:

1. `model = Sequential()`: Ini membuat model keras berurutan yang akan digunakan
untuk menggabungkan lapisan-lapisan secara berurutan.
2. `model.add(Flatten(input_shape=img_shape)`: Ini adalah lapisan Flatten yang
digunakan untuk mengubah gambar dengan bentuk yang sesuai (sesuai dengan
`img_shape`) menjadi vektor 1D untuk input ke lapisan-lapisan berikutnya.
3. Lalu, ada beberapa lapisan dense dalam model:

- `model.add(Dense(512)`: Lapisan dense dengan 512 neuron.

- `model.add(LeakyReLU(alpha=0.2))`: Lapisan aktivasi LeakyReLU.

- `model.add(Dense(256)`: Lapisan dense dengan 256 neuron.
- `model.add(Dense(1, activation='sigmoid'))`: Lapisan dense terakhir dengan satu
neuron yang menghasilkan nilai dalam rentang 0 hingga 1 menggunakan fungsi
aktivasi sigmoid. Nilai yang dihasilkan oleh lapisan ini akan mendekati 0 jika
gambar dianggap palsu (hasil dari generator) dan mendekati 1 jika gambar
dianggap nyata (hasil dari dataset).
4. `model.summary()`: Ini mencetak ringkasan model yang menampilkan detail
tentang jumlah parameter di setiap lapisan dan dimensi keluaran.

Setelah model discriminator dibangun, langkah terakhir adalah

mengompilasi model ini dengan menentukan loss function (fungsi kerugian),
optimizer, dan metrik evaluasi. Dalam kasus ini, model discriminator menggunakan
loss function 'binary_crossentropy' karena tugasnya adalah untuk
mengklasifikasikan apakah gambar adalah palsu atau nyata. Optimizer yang
digunakan adalah `adam`, yang sudah didefinisikan sebelumnya, dan metrik
evaluasi adalah akurasi ('accuracy') untuk melihat seberapa baik model dalam
mengklasifikasikan gambar-gambar. Model discriminator ini kemudian akan
digunakan dalam proses pelatihan GAN untuk membantu melatih model generator.

Codingan ini adalah bagian akhir dari implementasi GAN (Generative

Adversarial Network). Ini adalah langkah-langkah untuk menggabungkan model
generator dan model discriminator ke dalam satu model GAN. Berikut adalah
penjelasan langkah demi langkah:
1. `GAN = Sequential()`: Ini membuat model keras berurutan yang akan digunakan
untuk menggabungkan model generator dan model discriminator.

2. `discriminator.trainable = False`: Dalam model GAN, kita mengatur model

discriminator sebagai tidak dapat dilatih (trainable = False) ketika digunakan
dalam model GAN. Ini dilakukan karena selama pelatihan GAN, kita hanya ingin
melatih model generator, dan model discriminator tidak boleh mengalami
pembaruan parameter dalam langkah ini.
3. `GAN.add(generator)`: Ini menambahkan model generator ke dalam model
GAN.

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

model GAN setelah model generator. Dengan demikian, model GAN memiliki
dua lapisan, generator diikuti oleh discriminator.
5. `GAN.compile(loss='binary_crossentropy', optimizer=adam)`: Ini mengompilasi
model GAN. Loss function yang digunakan adalah 'binary_crossentropy' karena
tugas utama model GAN adalah menghasilkan keluaran yang mendekati 0 untuk
gambar palsu dan mendekati 1 untuk gambar nyata. Optimizer yang digunakan
adalah `adam`, yang sudah didefinisikan sebelumnya.
6. `GAN.summary()`: Ini mencetak ringkasan model GAN yang menampilkan
detail tentang jumlah parameter di setiap lapisan dan dimensi keluaran.
Model GAN yang dibuat dengan langkah-langkah ini akan digunakan dalam
proses pelatihan GAN untuk melatih model generator sedemikian rupa sehingga
menghasilkan gambar-gambar yang semakin mendekati gambar nyata dan
mengelabui model discriminator.
 Codingan ini adalah bagian dari proses untuk menghasilkan dan menyimpan
gambar-gambar yang dihasilkan oleh model generator selama pelatihan GAN.
Berikut adalah penjelasan dari kode tersebut:

1. Import modul yang dibutuhkan, seperti `matplotlib.pyplot` untuk visualisasi

gambar, `glob` untuk manajemen berkas, `imageio` untuk menyimpan gambar, dan
`PIL` (Pillow) untuk pengolahan gambar.
2. `save_name` adalah variabel yang digunakan untuk memberikan nama unik
kepada setiap gambar yang disimpan. Nilai awalnya diatur sebagai `0.00000000`.
3. `save_imgs(epoch)`: Ini adalah fungsi yang digunakan untuk menghasilkan
dan menyimpan gambar-gambar yang dihasilkan oleh generator pada setiap tahap
pelatihan GAN (ditentukan oleh `epoch`). Fungsi ini melakukan langkah-langkah
berikut:
- Membuat matriks noise dengan angka acak yang akan digunakan sebagai input
untuk generator.
- Menggunakan model generator untuk menghasilkan gambar-gambar sintetis
(`gen_imgs`) berdasarkan vektor noise.
- Menambahkan nilai ke `save_name` untuk memberikan nama yang berbeda pada
setiap gambar yang disimpan.
- Menormalisasi gambar-gambar tersebut agar rentang nilai pikselnya antara 0 dan
1. - Membuat tampilan subplot berdasarkan jumlah baris `r` dan kolom `c`
(dalam kode ini, 5 baris dan 5 kolom).
- Memasukkan gambar-gambar hasil generasi ke dalam subplot.

- Menyimpan gambar-gambar ini dengan format nama file yang mencerminkan

nilai `save_name`. Gambar-gambar ini disimpan dalam direktori
"generated_images".
- Menutup tampilan gambar setelah gambar-gambar tersebut disimpan.

Fungsi ini membantu dalam memantau kemajuan pelatihan GAN dengan

menghasilkan dan menyimpan gambar-gambar yang dihasilkan oleh generator pada
setiap tahap pelatihan.
 Codingan ini adalah implementasi dari proses pelatihan GAN (Generative
Adversarial Network) yang melibatkan pelatihan model discriminator dan generator
secara bergantian.

Berikut adalah penjelasan langkah demi langkah:

1. Memuat dataset MNIST dengan menggunakan `mnist.load_data()`. Namun,

dalam kasus ini, hanya X_train (gambar-gambar) yang digunakan, dan label tidak
relevan.
2. Normalisasi data: Gambar-gambar dalam dataset diubah agar nilainya berada
dalam rentang antara -1 dan 1. Ini umum dalam pelatihan GAN.
3. Membuat vektor `valid` dan `fakes` sebagai label yang digunakan dalam
pelatihan model. `valid` adalah vektor yang berisi nilai 1 yang akan digunakan
sebagai label gambar-gambar nyata, sementara `fakes` adalah vektor yang berisi
nilai 0 yang digunakan sebagai label gambar-gambar palsu yang dihasilkan oleh
generator.
4. Loop pelatihan untuk sejumlah `epochs` (misalnya, 30,000 epochs) dengan batch
size sebesar `batch_size` (dalam contoh ini, 64) dan interval penyimpanan
gambar hasil generasi setiap `save_interval` epochs.
5. Pada setiap epoch:

- Diambil batch gambar-gambar nyata secara acak dari dataset.

- Dibangkitkan gambar-gambar palsu oleh generator menggunakan vektor noise

acak.

- Model discriminator diperbarui dua kali: pertama dengan gambar-gambar nyata

dan label `valid`, dan kedua dengan gambar-gambar palsu dan label `fakes`.
Dalam kedua kasus ini, diperhitungkan kerugian (loss) dari model discriminator.
- Model generator diperbarui dengan menghasilkan gambar-gambar palsu dan
mencoba untuk meyakinkan model discriminator bahwa gambar-gambar tersebut
adalah nyata. Ini menghasilkan kerugian untuk model generator.
6. Setiap `save_interval` epoch, gambar-gambar yang dihasilkan oleh
generator disimpan menggunakan fungsi `save_imgs` untuk memantau kemajuan
generasi gambar selama pelatihan.
7. Pada setiap epoch, cetak hasil pelatihan, termasuk loss model discriminator
(d_loss) dan loss model generator (g_loss).

Proses ini akan terus berlanjut hingga jumlah `epochs` yang telah ditentukan
selesai. Selama pelatihan, model generator akan berusaha untuk menghasilkan
gambar-gambar yang semakin mendekati gambar nyata, sementara model
discriminator akan berusaha untuk membedakan gambar-gambar palsu dari yang
nyata. Hasil pelatihan yang berhasil akan menghasilkan generator yang mampu
menghasilkan gambar-gambar yang semakin realistis.

Codingan ini memiliki beberapa kesalahan yang perlu diperbaiki. Terdapat

beberapa kesalahan sintaksis yang perlu diperbaiki, dan beberapa perulangan yang
tidak diperlukan. Berikut adalah kode yang diperbaiki:

```python

# Display a single image using the epoch number def

display_image(epoch_no): return

PIL.Image.open('generated_images/{:08f}.png'.format(epoch_no))

anim_file = 'dcgan.gif'

with imageio.get_writer(anim_file, mode='I') as writer:

filenames =
glob.glob('generated_images/*.png')
filenames = sorted(filenames) for
filename in filenames: image =
imageio.imread(filename)
writer.append_data(image)
```

Kode ini menciptakan sebuah GIF yang berisi gambar-gambar yang dihasilkan
oleh model generator selama pelatihan GAN. Prosesnya adalah sebagai berikut:

1. Membuat fungsi `display_image(epoch_no)` yang digunakan untuk membuka

dan menampilkan gambar dari path yang sesuai dengan nomor epoch yang
diberikan.
2. Menentukan nama file untuk animasi GIF yang akan dihasilkan, dalam hal ini,
`dcgan.gif`.

3. Menggunakan `imageio.get_writer` untuk membuat penulis GIF.

4. Menggunakan `glob.glob` untuk mengumpulkan daftar nama file gambar yang

akan digabungkan dalam animasi. File-file ini harus ada dalam direktori
"generated_images".
5. Mengurutkan nama file gambar tersebut.

6. Membuka setiap file gambar, membacanya menggunakan `imageio.imread`, dan

menambahkannya ke animasi yang sedang ditulis menggunakan
`writer.append_data`.
Dengan cara ini, Anda dapat membuat animasi GIF yang menunjukkan evolusi
gambar-gambar yang dihasilkan oleh model generator seiring dengan peningkatan
pelatihan GAN.