Spaces:
No application file
No application file
File size: 6,121 Bytes
6f88715 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | # Combining Autoencoders and GANs involves training both models simultaneously. The Autoencoder is responsible for reconstructing input images, while the GAN ensures that the generated images from random noise are realistic. Below is a simplified example of combining Autoencoders and GANs in Keras:
# ```python
import os
import cv2
import numpy as np
from PIL import Image
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, Dense, Reshape, Flatten
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import binary_crossentropy
from tensorflow.keras.datasets import mnist # Example dataset, replace with your data
import matplotlib.pyplot as plt
# Function to load face images from a folder
def load_faces_from_folder(folder_path):
faces = []
for filename in os.listdir(folder_path):
img_path = os.path.join(folder_path, filename)
face_image = Image.open(img_path)
face_array = np.array(face_image.resize((128, 128))) / 255.0 # Normalize pixel values
faces.append(face_array)
return np.array(faces)
# Function to build the autoencoder
def build_autoencoder(input_shape):
input_img = Input(shape=input_shape)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)
# Decoder
x = Conv2D(128, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(3, (3, 3), activation='sigmoid', padding='same')(x)
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adam', loss='mean_squared_error')
return autoencoder
# Function to build the generator for GAN
def build_generator(latent_dim, img_shape):
model_input = Input(shape=(latent_dim,))
# Adjust the following line based on the desired output shape
x = Dense(32 * 32 * 64, activation='relu')(model_input)
x = Reshape((32, 32, 64))(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
generated_img = Conv2D(3, (3, 3), activation='sigmoid', padding='same')(x)
generator = Model(model_input, generated_img)
return generator
# Function to build the discriminator for GAN
def build_discriminator(img_shape):
model_input = Input(shape=img_shape)
x = Conv2D(64, (3, 3), strides=(2, 2), padding='same', activation='relu')(model_input)
x = Conv2D(128, (3, 3), strides=(2, 2), padding='same', activation='relu')(x)
x = Flatten()(x)
x = Dense(1, activation='sigmoid')(x)
discriminator = Model(model_input, x)
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return discriminator
# Function to build the GAN model
# Function to build the GAN model
def build_gan(generator, discriminator, autoencoder, latent_dim):
discriminator.trainable = False
gan_input = Input(shape=(latent_dim,))
generated_img = generator(gan_input)
validity = discriminator(autoencoder(generated_img))
gan = Model(gan_input, validity)
gan.compile(optimizer='adam', loss='binary_crossentropy')
return gan
# Function to train Autoencoder-GAN
def train_autoencoder_gan(autoencoder, generator, discriminator, gan, x_train, epochs=100, batch_size=128):
latent_dim = 100 # Adjust based on your requirements
# Training loop
for epoch in range(epochs):
idx = np.random.randint(0, x_train.shape[0], batch_size)
real_imgs = x_train[idx]
# Generate random noise as input to the generator
noise = np.random.normal(0, 1, (batch_size, latent_dim))
generated_imgs = generator.predict(noise)
# Train discriminator
d_loss_real = discriminator.train_on_batch(real_imgs, np.ones((batch_size, 1)))
d_loss_fake = discriminator.train_on_batch(generated_imgs, np.zeros((batch_size, 1)))
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Train generator (via the gan model)
noise = np.random.normal(0, 1, (batch_size, latent_dim))
valid_y = np.array([1] * batch_size)
g_loss = gan.train_on_batch(noise, valid_y)
# Print progress
print(f"Epoch {epoch}/{epochs} [D loss: {d_loss[0]} | D accuracy: {100 * d_loss[1]}] [G loss: {g_loss}]")
if __name__ == "__main__":
# Specify the output folder containing the face images
faces_folder = "/content/drive/MyDrive/dataset_major/dataset" # Change this to your actual output folder
# Load face images
faces = load_faces_from_folder(faces_folder)
# Build Autoencoder, Generator, Discriminator, and GAN
autoencoder = build_autoencoder(input_shape=(128, 128, 3))
generator = build_generator(latent_dim=100, img_shape=(128, 128, 3))
discriminator = build_discriminator(img_shape=(128, 128, 3))
gan = build_gan(generator, discriminator, autoencoder, latent_dim=100)
# Train Autoencoder-GAN
train_autoencoder_gan(autoencoder, generator, discriminator, gan, faces, epochs=5, batch_size=128)
# Generate some images using the trained generator
num_generated_images = 5
latent_dim = 100
noise = np.random.normal(0, 1, (num_generated_images, latent_dim))
generated_images = generator.predict(noise)
# Display the generated images
fig, axes = plt.subplots(1, num_generated_images, figsize=(15, 3))
for i in range(num_generated_images):
axes[i].imshow(generated_images[i])
axes[i].axis('off')
axes[i].set_title(f"Generated Image {i+1}")
plt.show()
|