{
 "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.450815677642822\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": [
    {
     "ename": "ValueError",
     "evalue": "Expected 1D or 2D array, got 5D array instead",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-04708a74e748>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavetxt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'images.txt'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimages\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdelimiter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m','\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfmt\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'%d'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/lib/npyio.py\u001b[0m in \u001b[0;36msavetxt\u001b[0;34m(fname, X, fmt, delimiter, newline, header, footer, comments, encoding)\u001b[0m\n\u001b[1;32m   1568\u001b[0m         \u001b[0;31m# Handle 1-dimensional arrays\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1569\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1570\u001b[0;31m             raise ValueError(\n\u001b[0m\u001b[1;32m   1571\u001b[0m                 \"Expected 1D or 2D array, got %dD array instead\" % X.ndim)\n\u001b[1;32m   1572\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Expected 1D or 2D array, got 5D array instead"
     ]
    }
   ],
   "source": [
    "np.savetxt('images.txt', images, delimiter=',', fmt='%d')"
   ]
  },
  {
   "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
}