ulepsz mój model, abym mógł osiągnąć lepsze wyniki, przepisz cały kod, zwróć uwage na…
- User
ulepsz mój model, abym mógł osiągnąć lepsze wyniki, przepisz cały kod, zwróć uwage na shape: import tensorflow as tf from tensorflow.keras.layers import Input, Dense, Reshape, Conv2DTranspose, Conv2D, Flatten from tensorflow.keras.models import Model from tensorflow.keras.datasets import cifar10 import numpy as np import matplotlib.pyplot as plt from tensorflow.keras.layers import Layer
Sampling Layer
class Sampling(Layer): def call(self, inputs): z_mean, z_log_var = inputs epsilon = tf.keras.backend.random_normal(shape=tf.shape(z_mean)) return z_mean + tf.exp(0.5 * z_log_var) * epsilon
Encoder
def build_conv_encoder(input_shape, latent_dim): input_img = Input(shape=input_shape) x = Conv2D(32, kernel_size=3, strides=2, activation='relu', padding='same')(input_img) x = Conv2D(40, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2D(48, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2D(56, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2D(64, kernel_size=3, strides=2, activation='relu', padding='same')(x) x_shape = tf.keras.backend.int_shape(x)[1:] # Shape before flattening x = Flatten()(x) x = Dense(128, activation='relu')(x) z_mean = Dense(latent_dim, name='z_mean')(x) z_log_var = Dense(latent_dim, name='z_log_var')(x) z = Sampling()([z_mean, z_log_var]) encoder = Model(input_img, [z_mean, z_log_var, z], name='encoder') return encoder, x_shape
Decoder
def build_conv_decoder(x_shape, latent_dim, output_shape): latent_inputs = Input(shape=(latent_dim,)) x = Dense(np.prod(x_shape), activation='relu')(latent_inputs) x = Reshape(x_shape)(x) x = Conv2DTranspose(64, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2DTranspose(56, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2DTranspose(48, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2DTranspose(40, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2DTranspose(32, kernel_size=3, strides=2, activation='relu', padding='same')(x) outputs = Conv2DTranspose(output_shape[2], kernel_size=3, activation='sigmoid', padding='same')(x) decoder = Model(latent_inputs, outputs, name='decoder') return decoder
VAE Model
class VAE(Model): def init(self, encoder, decoder, kl_weight=1.0, **kwargs): super(VAE, self).init(**kwargs) self.encoder = encoder self.decoder = decoder self.kl_weight = kl_weight self.reconstruction_loss_tracker = tf.keras.metrics.Mean(name="reconstruction_loss") self.kl_loss_tracker = tf.keras.metrics.Mean(name="kl_loss")
def call(self, inputs): z_mean, z_log_var, z = self.encoder(inputs) reconstruction = self.decoder(z) return reconstruction def train_step(self, data): with tf.GradientTape() as tape: z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) reconstruction_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.binary_crossentropy(data, reconstruction), axis=(1, 2) ) ) kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum( z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1, axis=1 ) ) total_loss = reconstruction_loss + self.kl_weight * kl_loss grads = tape.gradient(total_loss, self.trainable_weights) self.optimizer.apply_gradients(zip(grads, self.trainable_weights)) # Update metrics self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return {"loss": total_loss, "reconstruction_loss": self.reconstruction_loss_tracker.result(), "kl_loss": self.kl_loss_tracker.result()} def test_step(self, data): z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) reconstruction_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.binary_crossentropy(data, reconstruction), axis=(1, 2) ) ) kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum( z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1, axis=1 ) ) total_loss = reconstruction_loss + self.kl_weight * kl_loss # Update metrics self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return {"loss": total_loss, "reconstruction_loss": self.reconstruction_loss_tracker.result(), "kl_loss": self.kl_loss_tracker.result()} @property def metrics(self): return [self.reconstruction_loss_tracker, self.kl_loss_tracker]Train VAE
def train_vae(input_shape, latent_dim, x_train, x_val, epochs=30, batch_size=128, dataset_name='Dataset'): encoder, x_shape = build_conv_encoder(input_shape, latent_dim) decoder = build_conv_decoder(x_shape, latent_dim, input_shape) vae = VAE(encoder, decoder, kl_weight=0.1) vae.compile(optimizer='adam', loss='mse') history = vae.fit( x_train, epochs=epochs, batch_size=batch_size, validation_data=(x_val, None) )
# Plot training losses plt.figure(figsize=(8, 6)) plt.plot(history.history['loss'], label='Training Total Loss') plt.plot(history.history['reconstruction_loss'], label='Training Reconstruction Loss') plt.xlabel('Epoch') plt.ylabel('Loss') plt.legend() plt.title(f'Training Loss on {dataset_name}') plt.show() # Reconstruct test images x_reconstructed = vae.predict(x_val[:10]) plot_reconstructions(x_val[:10], x_reconstructed, input_shape) return vaePlot original and reconstructed images
def plot_reconstructions(x_original, x_reconstructed, input_shape, num_images=10): plt.figure(figsize=(20, 4)) for i in range(num_images): ax = plt.subplot(2, num_images, i + 1) plt.imshow(x_original[i]) ax.axis('off') ax = plt.subplot(2, num_images, i + 1 + num_images) plt.imshow(x_reconstructed[i]) ax.axis('off') plt.tight_layout() plt.show()
Load CIFAR-10
(x_train_cifar, _), (x_test_cifar, _) = cifar10.load_data() x_train_cifar = x_train_cifar.astype('float32') / 255. x_test_cifar = x_test_cifar.astype('float32') / 255.
Train VAE on CIFAR-10
vae_cifar = train_vae( input_shape=(32, 32, 3), latent_dim=32, x_train=x_train_cifar, x_val=x_test_cifar, epochs=30, batch_size=256, dataset_name='CIFAR-10' )
- Assistant
Oczywiście! Poniżej znajduje się ulepszona wersja Twojego modelu Variational Autoencoder (VAE) dla zestawu danych CIFAR-10. Wprowadziłem kilka kluczowych modyfikacji, aby poprawić wydajność i stabilność modelu:
-
Architektura Enkoder i Dekoder:
- Zwiększenie liczby filtrów: Większa liczba filtrów w warstwach konwolucyjnych pozwala modelowi lepiej uchwycić złożone cechy danych.
- Batch Normalization: Dodanie normalizacji warstwowej przyspiesza trening i stabilizuje proces uczenia.
- LeakyReLU: Użycie aktywacji LeakyReLU pomaga w uniknięciu problemu tzw. "znikającego gradientu".
-
Funkcja Strat:
- MSE zamiast Binary Crossentropy: Dla obrazów kolorowych (RGB) lepszym wyborem jest użycie MSE, który lepiej uchwyci różnice w wartościach pikseli.
-
Dimensje Latentne:
- Zwiększenie wymiaru latentnego: Większy wymiar latentny (np. 128) pozwala modelowi przechować więcej informacji o danych wejściowych.
-
Podział Danych:
- Tworzenie zbioru walidacyjnego: Podział zestawu treningowego na treningowy i walidacyjny pozwala lepiej monitorować wydajność modelu na danych niewidocznych podczas treningu.
-
Poprawki Techniczne:
- Poprawa obsługi kształtów: Upewnienie się, że warstwy enkodera i dekodera są odpowiednio zbalansowane pod względem rozmiarów tensorów.
- Lepsze zarządzanie stratami w klasie
VAE.
Oto kompletny, ulepszony kod:
import tensorflow as tf from tensorflow.keras.layers import Input, Dense, Reshape, Conv2DTranspose, Conv2D, Flatten, BatchNormalization, LeakyReLU from tensorflow.keras.models import Model from tensorflow.keras.datasets import cifar10 import numpy as np import matplotlib.pyplot as plt from tensorflow.keras.layers import Layer # Warstwa próbkowania class Sampling(Layer): def call(self, inputs): z_mean, z_log_var = inputs epsilon = tf.random.normal(shape=tf.shape(z_mean)) return z_mean + tf.exp(0.5 * z_log_var) * epsilon # Enkoder def build_conv_encoder(input_shape, latent_dim): input_img = Input(shape=input_shape, name='encoder_input') x = Conv2D(64, kernel_size=3, strides=2, padding='same')(input_img) # 32x32 -> 16x16 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2D(128, kernel_size=3, strides=2, padding='same')(x) # 16x16 -> 8x8 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2D(256, kernel_size=3, strides=2, padding='same')(x) # 8x8 -> 4x4 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2D(512, kernel_size=3, strides=2, padding='same')(x) # 4x4 -> 2x2 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Flatten()(x) x = Dense(256)(x) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) z_mean = Dense(latent_dim, name='z_mean')(x) z_log_var = Dense(latent_dim, name='z_log_var')(x) z = Sampling()([z_mean, z_log_var]) encoder = Model(input_img, [z_mean, z_log_var, z], name='encoder') encoder.summary() return encoder # Dekoder def build_conv_decoder(input_shape, latent_dim): # Kształt przed spłaszczeniem w enkoderze x_shape = (2, 2, 512) latent_inputs = Input(shape=(latent_dim,), name='z_sampling') x = Dense(np.prod(x_shape))(latent_inputs) x = Reshape(x_shape)(x) x = Conv2DTranspose(512, kernel_size=3, strides=2, padding='same')(x) # 2x2 -> 4x4 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2DTranspose(256, kernel_size=3, strides=2, padding='same')(x) # 4x4 -> 8x8 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2DTranspose(128, kernel_size=3, strides=2, padding='same')(x) # 8x8 -> 16x16 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2DTranspose(64, kernel_size=3, strides=2, padding='same')(x) # 16x16 -> 32x32 x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) outputs = Conv2DTranspose(input_shape[2], kernel_size=3, activation='sigmoid', padding='same', name='decoder_output')(x) decoder = Model(latent_inputs, outputs, name='decoder') decoder.summary() return decoder # Model VAE class VAE(Model): def __init__(self, encoder, decoder, kl_weight=1.0, **kwargs): super(VAE, self).__init__(**kwargs) self.encoder = encoder self.decoder = decoder self.kl_weight = kl_weight self.total_loss_tracker = tf.keras.metrics.Mean(name="loss") self.reconstruction_loss_tracker = tf.keras.metrics.Mean(name="reconstruction_loss") self.kl_loss_tracker = tf.keras.metrics.Mean(name="kl_loss") def call(self, inputs): z_mean, z_log_var, z = self.encoder(inputs) reconstruction = self.decoder(z) return reconstruction def train_step(self, data): if isinstance(data, tuple): data = data[0] with tf.GradientTape() as tape: z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) # Obliczanie straty rekonstrukcji (MSE) reconstruction_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.mse(data, reconstruction), axis=(1,2,3) ) ) # Obliczanie KL dywergencji kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=1) ) # Całkowita strata total_loss = reconstruction_loss + self.kl_weight * kl_loss grads = tape.gradient(total_loss, self.trainable_weights) self.optimizer.apply_gradients(zip(grads, self.trainable_weights)) # Aktualizacja metryk self.total_loss_tracker.update_state(total_loss) self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return { "loss": self.total_loss_tracker.result(), "reconstruction_loss": self.reconstruction_loss_tracker.result(), "kl_loss": self.kl_loss_tracker.result(), } def test_step(self, data): if isinstance(data, tuple): data = data[0] z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) reconstruction_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.mse(data, reconstruction), axis=(1,2,3) ) ) kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=1) ) total_loss = reconstruction_loss + self.kl_weight * kl_loss # Aktualizacja metryk self.total_loss_tracker.update_state(total_loss) self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return { "loss": self.total_loss_tracker.result(), "reconstruction_loss": self.reconstruction_loss_tracker.result(), "kl_loss": self.kl_loss_tracker.result(), } @property def metrics(self): return [self.total_loss_tracker, self.reconstruction_loss_tracker, self.kl_loss_tracker] # Funkcja treningowa VAE def train_vae(input_shape, latent_dim, x_train, x_val, epochs=50, batch_size=128, kl_weight=1.0, dataset_name='Dataset'): encoder = build_conv_encoder(input_shape, latent_dim) decoder = build_conv_decoder(input_shape, latent_dim) vae = VAE(encoder, decoder, kl_weight=kl_weight) vae.compile(optimizer=tf.keras.optimizers.Adam()) history = vae.fit( x_train, epochs=epochs, batch_size=batch_size, validation_data=(x_val, None) ) # Wykres strat treningowych plt.figure(figsize=(8, 6)) plt.plot(history.history['loss'], label='Strata całkowita (Training)') plt.plot(history.history['reconstruction_loss'], label='Strata rekonstrukcji (Training)') plt.plot(history.history['kl_loss'], label='Strata KL (Training)') plt.xlabel('Epoka') plt.ylabel('Strata') plt.legend() plt.title(f'Historia treningu na {dataset_name}') plt.show() # Rekonstrukcja obrazów testowych x_reconstructed = vae.predict(x_val[:10]) plot_reconstructions(x_val[:10], x_reconstructed, input_shape) return vae # Funkcja do wizualizacji oryginalnych i zrekonstruowanych obrazów def plot_reconstructions(x_original, x_reconstructed, input_shape, num_images=10): plt.figure(figsize=(20, 4)) for i in range(num_images): # Oryginalny obraz ax = plt.subplot(2, num_images, i + 1) plt.imshow(x_original[i]) ax.axis('off') # Zrekonstruowany obraz ax = plt.subplot(2, num_images, i + 1 + num_images) plt.imshow(x_reconstructed[i]) ax.axis('off') plt.tight_layout() plt.show() # Ładowanie danych CIFAR-10 (x_train_cifar, _), (x_test_cifar, _) = cifar10.load_data() x_train_cifar = x_train_cifar.astype('float32') / 255. x_test_cifar = x_test_cifar.astype('float32') / 255. # Podział danych treningowych na treningowy i walidacyjny from sklearn.model_selection import train_test_split x_train_cifar, x_val_cifar = train_test_split(x_train_cifar, test_size=0.1, random_state=42) # Trenowanie VAE na CIFAR-10 vae_cifar = train_vae( input_shape=(32, 32, 3), latent_dim=128, x_train=x_train_cifar, x_val=x_val_cifar, epochs=50, batch_size=128, kl_weight=1.0, dataset_name='CIFAR-10' )Wyjaśnienia Kluczowych Poprawek:
-
Architektura Enkoder i Dekoder:
- Filtry: Rozpoczęliśmy od 64 filtrów w pierwszej warstwie konwolucyjnej, stopniowo zwiększając do 512 w głębszych warstwach. To pozwala modelowi uchwycić bardziej złożone cechy.
- Batch Normalization i LeakyReLU: Te warstwy pomagają w stabilizacji treningu i umożliwiają modelowi efektywniejsze uczenie się nieliniowych zależności.
-
Dimensje Latentne:
- Latent_dim=128: Większy wymiar latentny pozwala na przechowywanie więcej informacji, co może prowadzić do lepszej jakości rekonstrukcji.
-
Funkcja Strat:
- Użycie
tf.keras.losses.msezamiastbinary_crossentropyjest bardziej odpowiednie dla obrazów kolorowych, ponieważ lepiej uchwyci różnice w wartościach pikseli w skali ciągłej.
- Użycie
-
Podział Danych:
- Użycie
train_test_splitz bibliotekisklearnpozwala na utworzenie zbioru walidacyjnego z danych treningowych, co jest kluczowe do monitorowania wydajności modelu na niewidocznych danych.
- Użycie
-
Wizualizacja:
- Dodano funkcję
plot_reconstructions, która umożliwia wizualne porównanie oryginalnych i zrekonstruowanych obrazów, co jest pomocne w ocenie jakości modelu.
- Dodano funkcję
-
Podsumowanie Modelu:
- Wywołanie
encoder.summary()idecoder.summary()pozwala na przegląd architektury modeli, co jest przydatne do debugowania i optymalizacji.
- Wywołanie
Dodatkowe Wskazówki:
- Liczba Epok: Zwiększenie liczby epok (np. do 50) może pomóc modelowi w lepszym dostosowaniu się do danych, ale uważaj na przeuczenie.
- Wymiar Latentny: Możesz eksperymentować z różnymi wymiarami latentnymi (np. 64, 256) w zależności od potrzeb i dostępnych zasobów obliczeniowych.
- Optymalizacja: Możesz spróbować różnych optymalizatorów lub dostosować parametry istniejącego (np. learning rate), aby poprawić szybkość i jakość treningu.
Mam nadzieję, że te zmiany pomogą Ci osiągnąć lepsze wyniki w Twoim modelu VAE! Jeśli masz dodatkowe pytania lub potrzebujesz dalszych modyfikacji, daj znać.
-