{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-18T11:01:17.933531Z",
     "iopub.status.busy": "2023-06-18T11:01:17.932980Z",
     "iopub.status.idle": "2023-06-18T11:01:26.600102Z",
     "shell.execute_reply": "2023-06-18T11:01:26.599102Z",
     "shell.execute_reply.started": "2023-06-18T11:01:17.933494Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import PIL\n",
    "import time\n",
    "from skimage.io import imshow\n",
    "from IPython.display import display\n",
    "from skimage.transform import resize\n",
    "from tensorflow.keras.layers import Dense, BatchNormalization, LeakyReLU, Reshape\n",
    "from tensorflow.keras.layers import Conv2DTranspose, Input, Concatenate, Conv2D\n",
    "from tensorflow.keras.layers import Conv2D, Dropout, Flatten\n",
    "from tensorflow.keras.models import Model\n",
    "import os\n",
    "import glob\n",
    "from tensorflow.keras.callbacks import LambdaCallback\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-18T11:01:26.602964Z",
     "iopub.status.busy": "2023-06-18T11:01:26.602225Z",
     "iopub.status.idle": "2023-06-18T11:01:26.615300Z",
     "shell.execute_reply": "2023-06-18T11:01:26.614236Z",
     "shell.execute_reply.started": "2023-06-18T11:01:26.602934Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def Load_Pprepr_Data():\n",
    "    Data = tf.keras.datasets.cifar10.load_data()\n",
    "    (train_images , train_labels) , (test_images , test_labels) = Data\n",
    "    return train_images ,train_labels ,test_images ,test_labels\n",
    "\n",
    "\n",
    "\n",
    "def create_train_dataset(train_images, train_labels, batch_size):\n",
    "    \"\"\"\n",
    "    Creates a TensorFlow dataset for training the AC-GAN model.\n",
    "\n",
    "    Args:\n",
    "        train_images (ndarray): Array of training images.\n",
    "        train_labels (ndarray): Array of training labels.\n",
    "        batch_size (int): Number of samples per batch.\n",
    "\n",
    "    Returns:\n",
    "        tf.data.Dataset: Training dataset.\n",
    "    \"\"\"\n",
    "\n",
    "    # Calculate the buffer size based on the number of training images\n",
    "    BUFFER_SIZE = train_images.shape[0]\n",
    "    \n",
    "    # Create a dataset for the training labels and map them to one-hot encoded vectors\n",
    "    train_dataset_y = tf.data.Dataset.from_tensor_slices(train_labels[:, 0]).map(lambda y: tf.one_hot(y, 10))\n",
    "    \n",
    "    # Create a dataset for the training images\n",
    "    train_dataset_x = tf.data.Dataset.from_tensor_slices(train_images)\n",
    "    \n",
    "    # Combine the image and label datasets, shuffle, and batch them\n",
    "    train_dataset = tf.data.Dataset.zip((train_dataset_x, train_dataset_y)).shuffle(BUFFER_SIZE).batch(batch_size)\n",
    "    \n",
    "    return train_dataset\n",
    "\n",
    "\n",
    "\n",
    "def scale_image_to_float(image):\n",
    "    \"\"\"\n",
    "    Scales the pixel values of an image to the range [-1, 1].\n",
    "\n",
    "    Args:\n",
    "        image (numpy.ndarray): Input image.\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray: Image with pixel values scaled to the range [-1, 1].\n",
    "    \"\"\"\n",
    "    return (image.astype(np.float32) - 127.5) / 127.5\n",
    "\n",
    "\n",
    "def scale_image_to_uint8(image):\n",
    "    \"\"\"\n",
    "    Scales the pixel values of an image to the range [0, 255] and converts them to uint8.\n",
    "\n",
    "    Args:\n",
    "        image (numpy.ndarray): Input image.\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray: Image with pixel values scaled to the range [0, 255] and converted to uint8.\n",
    "    \"\"\"\n",
    "    return np.clip((image * 127.5) + 128, 0, 255).astype(np.uint8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-18T11:01:26.617981Z",
     "iopub.status.busy": "2023-06-18T11:01:26.617236Z",
     "iopub.status.idle": "2023-06-18T11:01:26.657572Z",
     "shell.execute_reply": "2023-06-18T11:01:26.656509Z",
     "shell.execute_reply.started": "2023-06-18T11:01:26.617949Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class AC_GAN:\n",
    "\n",
    "        \n",
    "        \n",
    "    def __init__(self):\n",
    "        self.generator = None\n",
    "        self.discriminator = None\n",
    "        self.generator_optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\n",
    "        self.discriminator_optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\n",
    "        self.generator_gradients = None\n",
    "        self.discriminator_gradients = None\n",
    "        \n",
    "        self.checkpoint_dir = './checkpoints'\n",
    "        os.makedirs(self.checkpoint_dir, exist_ok=True)\n",
    "        self.checkpoint_prefix = os.path.join(self.checkpoint_dir, 'ckpt')\n",
    "\n",
    "        # Rest of your code...\n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "    def build_generator(self,latent_dim, num_classes):\n",
    "        \"\"\"\n",
    "        Builds the AC-GAN generator model.\n",
    "\n",
    "        Args:\n",
    "            latent_dim (int): Dimension of the noise input.\n",
    "            num_classes (int): Number of classes/labels.\n",
    "\n",
    "        Returns:\n",
    "            generator (Model): The AC-GAN generator model.\n",
    "        \"\"\"\n",
    "        # Noise input and label input\n",
    "        noise_input = Input((latent_dim,))\n",
    "        label_input = Input((num_classes,))\n",
    "\n",
    "        # Concatenate noise and label inputs\n",
    "        x = Concatenate()([noise_input, label_input])\n",
    "\n",
    "        # Fully connected layer\n",
    "        x = Dense(4 * 4 * 256, use_bias=False)(x)\n",
    "        x = BatchNormalization()(x)\n",
    "        x = LeakyReLU()(x)\n",
    "\n",
    "        # Reshape to 4x4x256 feature maps\n",
    "        x = Reshape((4, 4, 256))(x)\n",
    "\n",
    "        # Transposed convolutional layers\n",
    "        x = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same', use_bias=False)(x)\n",
    "        x = BatchNormalization()(x)\n",
    "        x = LeakyReLU()(x)\n",
    "\n",
    "        x = Conv2DTranspose(64, (4, 4), strides=(2, 2), padding='same', use_bias=False)(x)\n",
    "        x = BatchNormalization()(x)\n",
    "        x = LeakyReLU()(x)\n",
    "\n",
    "        x = Conv2DTranspose(32, (4, 4), strides=(2, 2), padding='same', use_bias=False)(x)\n",
    "        x = BatchNormalization()(x)\n",
    "        x = LeakyReLU()(x)\n",
    "\n",
    "        # Output layer with tanh activation\n",
    "        output = Conv2D(3, (3, 3), strides=(1, 1), padding='same', activation='tanh')(x)\n",
    "\n",
    "        # Create the generator model\n",
    "        generator = Model(inputs=[noise_input, label_input], outputs=output)\n",
    "\n",
    "        return generator\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    def build_discriminator(self,input_shape):\n",
    "        \"\"\"\n",
    "        Build a discriminator model with the given input shape.\n",
    "\n",
    "        Parameters:\n",
    "            input_shape (tuple): Shape of the input images (height, width, channels).\n",
    "\n",
    "        Returns:\n",
    "            discriminator (Model): Discriminator model.\n",
    "\n",
    "        \"\"\"\n",
    "        _i = Input(input_shape)\n",
    "        _ = Conv2D(64, (3, 3), strides=(2, 2), padding='same')(_i)\n",
    "        _ = LeakyReLU()(_)  # Apply LeakyReLU activation\n",
    "        _ = Conv2D(128, (3, 3), strides=(2, 2), padding='same', use_bias=False)(_)\n",
    "        _ = BatchNormalization()(_)  # Apply batch normalization\n",
    "        _ = LeakyReLU()(_)  # Apply LeakyReLU activation\n",
    "        _ = Conv2D(128, (3, 3), strides=(2, 2), padding='same', use_bias=False)(_)\n",
    "        _ = BatchNormalization()(_)  # Apply batch normalization\n",
    "        _ = LeakyReLU()(_)  # Apply LeakyReLU activation\n",
    "        _ = Conv2D(128, (3, 3), strides=(2, 2), padding='same', use_bias=False)(_)\n",
    "        _ = BatchNormalization()(_)  # Apply batch normalization\n",
    "        _ = LeakyReLU()(_)  # Apply LeakyReLU activation\n",
    "        _ = Flatten()(_)\n",
    "        _0 = Dense(1)(_)  # Output for real/fake prediction\n",
    "        _1 = Dense(10)(_)  # Output for class prediction\n",
    "\n",
    "        discriminator = Model(inputs=_i, outputs=[_0, _1])\n",
    "        return discriminator\n",
    "    \n",
    "    def prepare_generation(self,num_generated_examples, latent_dim):\n",
    "        \"\"\"\n",
    "        Prepare vectors for image generation.\n",
    "\n",
    "        Args:\n",
    "            num_epochs (int): Number of training epochs.\n",
    "            num_generated_examples (int): Number of images to generate.\n",
    "            latent_dim (int): Dimension of the latent space vector.\n",
    "\n",
    "        Returns:\n",
    "            random_vector_for_generation (tf.Tensor): Random vector for generating images.\n",
    "            condition_vector_generation (tf.Tensor): Condition vector for generating images.\n",
    "        \"\"\"\n",
    "        # Generate random vector for image generation\n",
    "        random_vector_for_generation = tf.random.normal([num_generated_examples, latent_dim])\n",
    "        condition_vector_generation = tf.one_hot(list(range(10)) * 2, 10)\n",
    "\n",
    "\n",
    "        return random_vector_for_generation, condition_vector_generation\n",
    "    \n",
    "    \n",
    "    \n",
    "    def compute_compute_generator_loss(self,generated_output, labels):\n",
    "        \"\"\"\n",
    "        Computes the generator loss for adversarial and class label matching.\n",
    "\n",
    "        Args:\n",
    "            generated_output (tuple): Tuple containing the discriminator output and class predictions.\n",
    "            labels (tf.Tensor): True class labels.\n",
    "\n",
    "        Returns:\n",
    "            tf.Tensor: Total generator loss.\n",
    "\n",
    "        \"\"\"\n",
    "        out_d, out_c = generated_output\n",
    "\n",
    "        # Calculate the loss component for fooling the discriminator\n",
    "        loss_discrit = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(\n",
    "            labels=tf.ones_like(out_d), logits=out_d))\n",
    "\n",
    "        # Calculate the loss component for matching the desired classes\n",
    "        loss_create = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(\n",
    "            labels=labels, logits=out_c))\n",
    "\n",
    "        # Return the sum of the two loss components\n",
    "        whole_loss = loss_discrit + loss_create\n",
    "        return whole_loss\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    def compute_compute_discriminator_loss(self,real_discriminator_output, generated_discriminator_output, true_labels):\n",
    "        \"\"\"\n",
    "        Computes the discriminator loss for real and generated examples.\n",
    "\n",
    "        Args:\n",
    "            real_discriminator_output (tuple): Tuple containing the discriminator output and class predictions for real examples.\n",
    "            generated_discriminator_output (tuple): Tuple containing the discriminator output and class predictions for generated examples.\n",
    "            true_labels (tf.Tensor): True class labels.\n",
    "\n",
    "        Returns:\n",
    "            tf.Tensor: Total discriminator loss.\n",
    "\n",
    "        \"\"\"\n",
    "        real_output_d, real_output_c = real_discriminator_output\n",
    "\n",
    "        # Loss for real examples\n",
    "        real_loss_d = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(\n",
    "            labels=tf.ones_like(real_output_d), logits=real_output_d))\n",
    "        real_loss_c = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(\n",
    "            labels=true_labels, logits=real_output_c))\n",
    "        modified_real_loss = real_loss_d + real_loss_c\n",
    "\n",
    "        generated_output_d, generated_output_c = generated_discriminator_output\n",
    "\n",
    "        # Loss for generated examples\n",
    "        modified_generated_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(\n",
    "            labels=tf.zeros_like(generated_output_d), logits=generated_output_d))\n",
    "\n",
    "        # Total loss\n",
    "        modified_total_loss = modified_real_loss + modified_generated_loss\n",
    "\n",
    "        return modified_total_loss\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    def train_model(self,input_images, input_labels,latent_dim,BATCH_SIZE):\n",
    "        \"\"\"\n",
    "        Performs a single training step for the generator and discriminator models.\n",
    "\n",
    "        Args:\n",
    "            input_images (tf.Tensor): Batch of real images.\n",
    "            input_labels (tf.Tensor): Batch of labels for the images.\n",
    "\n",
    "        Returns:\n",
    "            None\n",
    "        \"\"\"\n",
    "\n",
    "        # Generate random noise\n",
    "#         noise = tf.random.normal([25, latent_dim])\n",
    "        noise = tf.random.normal([BATCH_SIZE, latent_dim])\n",
    "#         print('ss')\n",
    "#         print(np.array(noise.shape))\n",
    "        # Generate random noise\n",
    "#         noise = np.random.normal(size=[20, latent_dim])\n",
    "\n",
    "\n",
    "        with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n",
    "            # Generate fake images\n",
    "            generated_images = self.generator([noise, input_labels], training=True)\n",
    "\n",
    "            # Get discriminator outputs for real and generated images\n",
    "            real_outputs = self.discriminator(input_images, training=True)\n",
    "            generated_outputs = self.discriminator(generated_images, training=True)\n",
    "\n",
    "            # Compute generator and discriminator losses\n",
    "            generator_loss = self.compute_compute_generator_loss(generated_outputs, input_labels)\n",
    "            discriminator_loss = self.compute_compute_discriminator_loss(real_outputs, generated_outputs, input_labels)\n",
    "\n",
    "        # Compute gradients for generator and discriminator\n",
    "        self.generator_gradients = gen_tape.gradient(generator_loss, self.generator.trainable_variables)\n",
    "        self.discriminator_gradients = disc_tape.gradient(discriminator_loss,self.discriminator.trainable_variables)\n",
    "\n",
    "        # Update generator and discriminator weights\n",
    "        self.generator_optimizer.apply_gradients(zip(self.generator_gradients, self.generator.trainable_variables))\n",
    "        self.discriminator_optimizer.apply_gradients(zip(self.discriminator_gradients, self.discriminator.trainable_variables))\n",
    "\n",
    "\n",
    "\n",
    "    def plot_images(self,images,epoch):\n",
    "\n",
    "        \n",
    "        np.save(\"all_images.npy\", np.array(images))\n",
    "        print(f' generated images of epoch {epoch} , saved to all_images.npy')\n",
    "        # Create a figure and axes for the subplots with larger figsize\n",
    "        fig, axes = plt.subplots(nrows=2, ncols=10, figsize=(40, 20))\n",
    "\n",
    "        # Flatten the axes array to simplify indexing\n",
    "        axes = axes.flatten()\n",
    "\n",
    "        # Iterate through the images and plot them in the subplots\n",
    "        for i in range(20):\n",
    "            axes[i].imshow(images[i])\n",
    "            axes[i].axis('off')\n",
    "\n",
    "\n",
    "        # Add a title to the entire subplot grid\n",
    "        fig.suptitle(f'Generated images of epoch :{epoch}', fontsize=42)\n",
    "\n",
    "        # Adjust the spacing between subplots\n",
    "        plt.tight_layout()\n",
    "\n",
    "        # Display the plot\n",
    "        plt.show()\n",
    "\n",
    "    def save_weights(self, checkpoint_name):\n",
    "        # Delete older weights\n",
    "        old_weights = glob.glob(f\"{self.checkpoint_prefix}*\")\n",
    "        for weight_file in old_weights:\n",
    "            os.remove(weight_file)\n",
    "\n",
    "        # Save the current weights\n",
    "        self.generator.save_weights(f\"{self.checkpoint_prefix}_generator_{checkpoint_name}.weights.h5\")\n",
    "        self.discriminator.save_weights(f\"{self.checkpoint_prefix}_discriminator_{checkpoint_name}.weights.h5\")\n",
    "\n",
    "\n",
    "        \n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "\n",
    "    def train(self, train_dataset, latent_dim, num_class, num_examples_to_generate, epochs, batch_size=25):\n",
    "        self.generator = self.build_generator(latent_dim, num_class)\n",
    "        self.discriminator = self.build_discriminator((32, 32, 3))\n",
    "\n",
    "        random_vector_for_generation, condition_vector_generation = self.prepare_generation(num_examples_to_generate,\n",
    "                                                                                           latent_dim)\n",
    "        generated = []\n",
    "\n",
    "        for epoch in range(epochs):\n",
    "            # Record the start time of the epoch\n",
    "            start_time = time.time()\n",
    "\n",
    "            # Iterate over the training dataset\n",
    "            for images, labels in train_dataset:\n",
    "                # Perform a single training step for the generator and discriminator models\n",
    "                self.train_model(images, labels, latent_dim, batch_size)\n",
    "\n",
    "            # fix extra errors for reproducing and fixing purposes--- noise should be tensor\n",
    "            # Generate random noise\n",
    "#             noise = np.random.normal(size=[num_examples_to_generate, latent_dim])\n",
    "#             print(noise.shape)\n",
    "            noise = tf.random.normal([num_examples_to_generate, latent_dim])\n",
    "\n",
    "            # Generate fake images using the generator model\n",
    "            generated_image = self.generator([noise, condition_vector_generation], training=False)\n",
    "            print(np.array(generated_image).shape)\n",
    "\n",
    "            self.plot_images(generated_image, epoch)\n",
    "            generated.append(generated_image)\n",
    "\n",
    "            # Print the epoch number and the time taken for the epoch\n",
    "            print(epoch, time.time() - start_time)\n",
    "\n",
    "            self.save_weights(f\"epoch_{epoch}\")\n",
    "\n",
    "        return np.array(generated)\n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "    \n",
    "        \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-18T11:01:26.660749Z",
     "iopub.status.busy": "2023-06-18T11:01:26.660332Z",
     "iopub.status.idle": "2023-06-18T11:01:39.868443Z",
     "shell.execute_reply": "2023-06-18T11:01:39.867491Z",
     "shell.execute_reply.started": "2023-06-18T11:01:26.660718Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "train_images ,train_labels ,test_images ,test_labels = Load_Pprepr_Data()\n",
    "train_img_f32 = scale_image_to_float(train_images)\n",
    "train_dataset = create_train_dataset(train_img_f32, train_labels, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-18T11:01:39.870224Z",
     "iopub.status.busy": "2023-06-18T11:01:39.869860Z",
     "iopub.status.idle": "2023-06-18T11:36:46.770590Z",
     "shell.execute_reply": "2023-06-18T11:36:46.769647Z",
     "shell.execute_reply.started": "2023-06-18T11:01:39.870191Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "False\n",
      "False\n",
      "no wieght found\n",
      "(20, 32, 32, 3)\n",
      " generated images of epoch 0 , saved to all_images.npy\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 4000x2000 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 9.06947112083435\n"
     ]
    }
   ],
   "source": [
    "train_dataset_small = train_dataset.take(16)  # for fast reproducing and fixing purposes\n",
    "\n",
    "\n",
    "print('start')\n",
    "acgn = AC_GAN()\n",
    "\n",
    "# Checkpoint directory\n",
    "checkpoint_dir = 'checkpoints'\n",
    "\n",
    "# Check generator and discriminator weights files\n",
    "generator_weights_file = os.path.join(checkpoint_dir, 'ckpt_generator_epoch_2')\n",
    "discriminator_weights_file = os.path.join(checkpoint_dir, 'ckpt_discriminator_epoch_2')\n",
    "\n",
    "# Check if the files exist\n",
    "generator_files_exist = os.path.exists(generator_weights_file + '.data-00000-of-00001') and \\\n",
    "                        os.path.exists(generator_weights_file + '.index')\n",
    "discriminator_files_exist = os.path.exists(discriminator_weights_file + '.data-00000-of-00001') and \\\n",
    "                            os.path.exists(discriminator_weights_file + '.index')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(generator_files_exist)\n",
    "print(discriminator_files_exist)\n",
    "if(generator_files_exist and discriminator_files_exist):\n",
    "    acgn.generator = acgn.build_generator(100, 10)  # Instantiate the generator\n",
    "    acgn.discriminator = acgn.build_discriminator((32, 32, 3))\n",
    "    acgn.generator.load_weights(generator_weights_file)\n",
    "    acgn.discriminator.load_weights(discriminator_weights_file)\n",
    "    images = acgn.train(train_dataset_small,100,10,20,1,25) # for fast reproducing and fixing purposes\n",
    "else:\n",
    "    print('no wieght found')\n",
    "    images = acgn.train(train_dataset_small,100,10,20,1,25) # for fast reproducing and fixing purposes\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-18T11:36:46.772208Z",
     "iopub.status.busy": "2023-06-18T11:36:46.771861Z",
     "iopub.status.idle": "2023-06-18T11:36:47.922580Z",
     "shell.execute_reply": "2023-06-18T11:36:47.920564Z",
     "shell.execute_reply.started": "2023-06-18T11:36:46.772176Z"
    }
   },
   "outputs": [],
   "source": [
    "# fix --- np.savetxt() only works with 1D or 2D arrays, but images variable has 5 dimensions\n",
    "# Save as a .npy file instead. Better for high-dimensional data\n",
    "# np.savetxt('images.txt', images, delimiter=',', fmt='%d')\n",
    "np.save('images.npy', images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-06-18T11:36:47.923861Z",
     "iopub.status.idle": "2023-06-18T11:36:47.924375Z",
     "shell.execute_reply": "2023-06-18T11:36:47.924120Z",
     "shell.execute_reply.started": "2023-06-18T11:36:47.924098Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-06-18T11:36:47.925915Z",
     "iopub.status.idle": "2023-06-18T11:36:47.926822Z",
     "shell.execute_reply": "2023-06-18T11:36:47.926613Z",
     "shell.execute_reply.started": "2023-06-18T11:36:47.926590Z"
    }
   },
   "outputs": [],
   "source": [
    "np.save('array.npy', images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-06-18T11:36:47.928141Z",
     "iopub.status.idle": "2023-06-18T11:36:47.929072Z",
     "shell.execute_reply": "2023-06-18T11:36:47.928843Z",
     "shell.execute_reply.started": "2023-06-18T11:36:47.928816Z"
    }
   },
   "outputs": [],
   "source": [
    "a = np.load('all_images.npy')\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-06-18T11:36:47.930595Z",
     "iopub.status.idle": "2023-06-18T11:36:47.931082Z",
     "shell.execute_reply": "2023-06-18T11:36:47.930834Z",
     "shell.execute_reply.started": "2023-06-18T11:36:47.930812Z"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(a.shape[0]):\n",
    "    # Get the current image\n",
    "    image = a[i]\n",
    "\n",
    "    # Plot the image\n",
    "    plt.figure()\n",
    "    plt.imshow(np.transpose(image, (0,1,2)))\n",
    "    plt.axis('off')\n",
    "    plt.title(f\"Image {i+1}\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-06-18T11:36:47.932689Z",
     "iopub.status.idle": "2023-06-18T11:36:47.933141Z",
     "shell.execute_reply": "2023-06-18T11:36:47.932926Z",
     "shell.execute_reply.started": "2023-06-18T11:36:47.932906Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "# Checkpoint directory\n",
    "checkpoint_dir = './checkpoints'\n",
    "\n",
    "# Check generator and discriminator weights files\n",
    "generator_weights_file = os.path.join(checkpoint_dir, 'ckpt_generator_epoch_2')\n",
    "discriminator_weights_file = os.path.join(checkpoint_dir, 'ckpt_discriminator_epoch_2')\n",
    "\n",
    "# Check if the files exist\n",
    "generator_files_exist = os.path.exists(generator_weights_file + '.data-00000-of-00001') and \\\n",
    "                        os.path.exists(generator_weights_file + '.index')\n",
    "discriminator_files_exist = os.path.exists(discriminator_weights_file + '.data-00000-of-00001') and \\\n",
    "                            os.path.exists(discriminator_weights_file + '.index')\n",
    "\n",
    "# Print the result\n",
    "print(\"Generator weights exist:\", generator_files_exist)\n",
    "print(\"Discriminator weights exist:\", discriminator_files_exist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-06-18T11:36:47.940409Z",
     "iopub.status.idle": "2023-06-18T11:36:47.940868Z",
     "shell.execute_reply": "2023-06-18T11:36:47.940649Z",
     "shell.execute_reply.started": "2023-06-18T11:36:47.940628Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "# Checkpoint directory\n",
    "checkpoint_dir = './checkpoints'\n",
    "\n",
    "# Check generator and discriminator weights files\n",
    "generator_weights_file = os.path.join(checkpoint_dir, 'ckpt_generator_epoch_2')\n",
    "discriminator_weights_file = os.path.join(checkpoint_dir, 'ckpt_discriminator_epoch_2')\n",
    "\n",
    "# Check if the files exist\n",
    "generator_files_exist = os.path.exists(generator_weights_file + '.data-00000-of-00001') and \\\n",
    "                        os.path.exists(generator_weights_file + '.index')\n",
    "discriminator_files_exist = os.path.exists(discriminator_weights_file + '.data-00000-of-00001') and \\\n",
    "                            os.path.exists(discriminator_weights_file + '.index')\n",
    "\n",
    "# Print the result\n",
    "print(\"Generator weights exist:\", generator_files_exist)\n",
    "print(\"Discriminator weights exist:\", discriminator_files_exist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-06-18T11:36:47.942551Z",
     "iopub.status.idle": "2023-06-18T11:36:47.943036Z",
     "shell.execute_reply": "2023-06-18T11:36:47.942819Z",
     "shell.execute_reply.started": "2023-06-18T11:36:47.942797Z"
    }
   },
   "outputs": [],
   "source": [
    "def load_weights(generator, discriminator, checkpoint_name):\n",
    "    generator_weights_file = f\"ckpt_generator_{checkpoint_name}\"\n",
    "    discriminator_weights_file = f\"ckpt_discriminator_{checkpoint_name}\"\n",
    "\n",
    "    generator_weights_exist = os.path.exists(generator_weights_file + '.data-00000-of-00001') and \\\n",
    "                              os.path.exists(generator_weights_file + '.index')\n",
    "    discriminator_weights_exist = os.path.exists(discriminator_weights_file + '.data-00000-of-00001') and \\\n",
    "                                  os.path.exists(discriminator_weights_file + '.index')\n",
    "\n",
    "    if generator_weights_exist and discriminator_weights_exist:\n",
    "        generator.load_weights(generator_weights_file)\n",
    "        discriminator.load_weights(discriminator_weights_file)\n",
    "        print(\"Weights loaded successfully.\")\n",
    "    else:\n",
    "        print(\"No weights found. Starting from scratch.\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}