Skip to content
The Chat Archive
gpt-3.5-turbo-0613· OpenAI WildChat-4.8M (AI2)

in python make an image generative ai, for now I just want it to train the model on the…

  1. User

    in python make an image generative ai, for now I just want it to train the model on the spot with images found in a folder. all the images are in diffrent sizes and I cant change them so you are gonna have to accomodate for that. make it train the model if it doesnt already detect one in the file system and if it does use it on the test data folder

  2. Assistant

    To create an image generative AI in Python, we can use a deep learning framework such as TensorFlow or PyTorch. Here's an example using TensorFlow's Keras API:

    import os
    import numpy as np
    import tensorflow as tf
    from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Conv2D, Conv2DTranspose
    from tensorflow.keras.models import Model
    from tensorflow.keras.optimizers import Adam
    from PIL import Image
    
    
    def load_images_from_folder(folder):
        images = []
        for filename in os.listdir(folder):
            img = Image.open(os.path.join(folder, filename))
            images.append(np.array(img))
        return np.array(images)
    
    
    def build_generator(latent_dim):
        inputs = Input(shape=(latent_dim,))
        x = Dense(128 * 7 * 7, activation='relu')(inputs)
        x = Reshape((7, 7, 128))(x)
        x = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(x)
        x = Conv2DTranspose(64, (4, 4), strides=(2, 2), padding='same')(x)
        x = Conv2DTranspose(1, (7, 7), activation='sigmoid', padding='same')(x)
        generator = Model(inputs=inputs, outputs=x)
        return generator
    
    
    def train_model(generator, images):
        images = (images - 127.5) / 127.5  # Normalize images to [-1, 1]
        dataset = tf.data.Dataset.from_tensor_slices(images).shuffle(len(images)).batch(batch_size=32)
        cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
        generator_optimizer = Adam(1e-4)
        latent_dim = generator.input_shape[1]
    
        @tf.function
        def train_step(images, generator):
            noise = tf.random.normal([len(images), latent_dim])
            with tf.GradientTape() as gen_tape:
                generated_images = generator(noise, training=True)
                gen_loss = cross_entropy(tf.ones_like(generated_images), generated_images)
    
            gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
            generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
    
        epochs = 100
        for epoch in range(epochs):
            for batch in dataset:
                train_step(batch, generator)
            if epoch % 10 == 0:
                print(f"Epoch {epoch} completed")
    
        return generator
    
    
    def save_generated_images(generator, test_samples=5, image_dim=28):
        noise = np.random.normal(0, 1, (test_samples, latent_dim))
        generated_images = generator.predict(noise)
        generated_images = generated_images.reshape(test_samples, image_dim, image_dim) * 127.5 + 127.5
        for i in range(test_samples):
            image = Image.fromarray(generated_images[i].astype(np.uint8))
            image.save(f"generated_image_{i}.png")
    
    
    # Main code
    image_folder = 'your_image_folder/'
    test_data_folder = 'your_test_data_folder/'
    model_file = 'generator_model.h5'
    
    if os.path.exists(model_file):
        generator = tf.keras.models.load_model(model_file)
    else:
        images = load_images_from_folder(image_folder)
        latent_dim = 100  # size of the generator's input noise vector
        generator = build_generator(latent_dim)
        generator = train_model(generator, images)
        generator.save(model_file)
    
    test_images = load_images_from_folder(test_data_folder)
    save_generated_images(generator, test_samples=len(test_images))
    
    

    Make sure to replace 'your_image_folder/' with the path to the folder containing your training images and 'your_test_data_folder/' with the folder containing the test images.

    Note: The above code assumes that the training images are grayscale. If your images have multiple channels (e.g., RGB), you might need to adjust the code accordingly.