train_imagen_all_stable copy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import configparser\n",
    "\n",
    "# Loading configurations\n",
    "configParser = configparser.RawConfigParser()   \n",
    "configFilePath = r'configuration.txt'\n",
    "configParser.read(configFilePath)\n",
    "\n",
    "insert_amd_env_vars =  int(configParser.get('COMMON', 'insert_amd_env_vars'))\n",
    "HSA_OVERRIDE_GFX_VERSION =  configParser.get('COMMON', 'HSA_OVERRIDE_GFX_VERSION')\n",
    "ROCM_PATH =  configParser.get('COMMON', 'ROCM_PATH')\n",
    "\n",
    "if(insert_amd_env_vars != 0):\n",
    "    os.environ[\"HSA_OVERRIDE_GFX_VERSION\"] = HSA_OVERRIDE_GFX_VERSION\n",
    "    os.environ[\"ROCM_PATH\"] = ROCM_PATH\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-12 10:26:58.558980: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-12 10:26:58.622793: I tensorflow/core/util/port.cc:104] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-12 10:26:59.131367: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
      "2023-11-12 10:26:59.131423: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
      "2023-11-12 10:26:59.131431: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default GPU Device: /device:GPU:0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-12 10:26:59.905243: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:26:59.953680: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:26:59.953868: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.459297: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.459454: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.459563: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.459658: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1613] Created device /device:GPU:0 with 20698 MB memory:  -> device: 0, name: Quadro RTX 6000, pci bus id: 0000:01:00.0, compute capability: 7.5\n",
      "2023-11-12 10:27:00.460269: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.460391: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.460485: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.460602: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.460698: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:00.460772: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1613] Created device /device:GPU:0 with 20698 MB memory:  -> device: 0, name: Quadro RTX 6000, pci bus id: 0000:01:00.0, compute capability: 7.5\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "if tf.test.gpu_device_name():\n",
    "    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))\n",
    "else:\n",
    "    print(\"Please install GPU version of TF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from textwrap import wrap\n",
    "import os\n",
    "import gc\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "#TODO document jupyter\n",
    "import pickle\n",
    "import configparser\n",
    "import sqlite3 as sl\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from pathlib import Path\n",
    "\n",
    "configParser = configparser.RawConfigParser()   \n",
    "configFilePath = r'configuration.txt'\n",
    "configParser.read(configFilePath)\n",
    "datasetPathDatabase =  configParser.get('COMMON', 'datasetPathDatabase') + '/dataset.db'\n",
    "datasetPathDatabaseAdditional =  configParser.get('COMMON', 'datasetPathDatabase') + '/datasetAdditional.db'\n",
    "datasetPathDatabaseVgg =  configParser.get('COMMON', 'datasetPathDatabase') + '/datasetFacesBlurred.db'\n",
    "image_size =  int(configParser.get('COMMON', 'resizeImageTo'))\n",
    "begin_with_image_size = int(configParser.get('COMMON', 'begin_with_image_size'))\n",
    "unet1_dim =  int(configParser.get('COMMON', 'unet1_dim'))\n",
    "unet2_dim =  int(configParser.get('COMMON', 'unet2_dim'))\n",
    "unet1_image_size =  int(configParser.get('COMMON', 'unet1_image_size'))\n",
    "audio_embs =  str(configParser.get('COMMON', 'audio_embs'))\n",
    "audio_length_used =  configParser.get('train_imagen', 'audio_length_used') \n",
    "model_filename =  configParser.get('train_imagen', 'model_filename')\n",
    "sub_epochs=  int(configParser.get('train_imagen', 'sub_epochs') )\n",
    "inner_epochs=  int(configParser.get('train_imagen', 'inner_epochs') )\n",
    "batch_size=  int(configParser.get('train_imagen', 'batch_size') )\n",
    "timesteps= int(configParser.get('COMMON', 'timesteps') )\n",
    "sample_every=  int(configParser.get('train_imagen', 'sample_every') ) - 1\n",
    "sample_probability = int(configParser.get('train_imagen', 'sample_probability') )\n",
    "save_model_every=  int(configParser.get('train_imagen', 'save_model_every') )\n",
    "sample_every_offset=  int(configParser.get('train_imagen', 'sample_every_offset') ) - 1\n",
    "save_every_offset=  int(configParser.get('train_imagen', 'save_every_offset') ) - 1\n",
    "imagen_samples_folder = configParser.get('train_imagen', 'imagen_samples_folder') \n",
    "db_chunk = int(configParser.get('train_imagen', 'db_chunk'))\n",
    "dask_chunk = int(configParser.get('train_imagen', 'dask_chunk'))\n",
    "stop_at_no_of_samples = int(configParser.get('train_imagen', 'stop_at_no_of_samples'))\n",
    "epochs = int(configParser.get('train_imagen', 'epochs'))\n",
    "ignore_speaker_embedding = bool(int(configParser.get('train_imagen', 'ignore_speaker_embedding') ))\n",
    "ignore_speech_brain = bool(int(configParser.get('train_imagen', 'ignore_speech_brain') ))\n",
    "ignore_pyannote_titanet_speakernet = bool(int(configParser.get('train_imagen', 'ignore_pyannote_titanet_speakernet') ))\n",
    "ignore_audio_features = bool(int(configParser.get('train_imagen', 'ignore_audio_features') ))\n",
    "ignore_pyAudioAnalysis = bool(int(configParser.get('train_imagen', 'ignore_pyAudioAnalysis') ))\n",
    "ignore_librosa = bool(int(configParser.get('train_imagen', 'ignore_librosa') ))\n",
    "ignore_image_guide = bool(int(configParser.get('train_imagen', 'ignore_image_guide') ))\n",
    "ignore_additional_attributes = bool(int(configParser.get('train_imagen', 'ignore_additional_attributes') ))\n",
    "ignore_age = bool(int(configParser.get('train_imagen', 'ignore_age') ))\n",
    "ignore_gender = bool(int(configParser.get('train_imagen', 'ignore_gender') ))\n",
    "ignore_ethnicity = bool(int(configParser.get('train_imagen', 'ignore_ethnicity') ))\n",
    "ignore_language_spoken = bool(int(configParser.get('train_imagen', 'ignore_language_spoken') ))\n",
    "\n",
    "\n",
    "pd.set_option('display.max_columns', None)\n",
    "pd.options.mode.chained_assignment = None\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gamal/anaconda3/envs/ds2f_m_s/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from textwrap import wrap\n",
    "import os\n",
    "\n",
    "import keras_cv\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import tensorflow.experimental.numpy as tnp\n",
    "from keras_cv.models.stable_diffusion.clip_tokenizer import SimpleTokenizer\n",
    "from keras_cv.models.stable_diffusion.diffusion_model import DiffusionModel\n",
    "from keras_cv.models.stable_diffusion.image_encoder import ImageEncoder\n",
    "from keras_cv.models.stable_diffusion.noise_scheduler import NoiseScheduler\n",
    "from keras_cv.models.stable_diffusion.text_encoder import TextEncoder\n",
    "from tensorflow import keras\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainer(tf.keras.Model):\n",
    "    # Reference:\n",
    "    # https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image.py\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        diffusion_model,\n",
    "        vae,\n",
    "        noise_scheduler,\n",
    "        use_mixed_precision=False,\n",
    "        max_grad_norm=1.0,\n",
    "        **kwargs\n",
    "    ):\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "        self.diffusion_model = diffusion_model\n",
    "        self.vae = vae\n",
    "        self.noise_scheduler = noise_scheduler\n",
    "        self.max_grad_norm = max_grad_norm\n",
    "\n",
    "        self.use_mixed_precision = use_mixed_precision\n",
    "        self.vae.trainable = False\n",
    "\n",
    "    def train_step(self,inputs):\n",
    "        images = inputs[\"images\"]\n",
    "        encoded_text = inputs[\"encoded_text\"]\n",
    "        batch_size = tf.shape(images)[0]\n",
    "\n",
    "        with tf.GradientTape() as tape:\n",
    "            # Project image into the latent space and sample from it.\n",
    "            latents = self.sample_from_encoder_outputs(self.vae(images, training=False))\n",
    "            # Know more about the magic number here:\n",
    "            # https://keras.io/examples/generative/fine_tune_via_textual_inversion/\n",
    "            latents = latents * 0.18215\n",
    "\n",
    "            # Sample noise that we'll add to the latents.\n",
    "            noise = tf.random.normal(tf.shape(latents))\n",
    "            #print(noise.shape)\n",
    "\n",
    "            # Sample a random timestep for each image.\n",
    "            timesteps = tnp.random.randint(\n",
    "                0, self.noise_scheduler.train_timesteps, (batch_size,)\n",
    "            )\n",
    "\n",
    "            # Add noise to the latents according to the noise magnitude at each timestep\n",
    "            # (this is the forward diffusion process).\n",
    "            noisy_latents = self.noise_scheduler.add_noise(\n",
    "                tf.cast(latents, noise.dtype), noise, timesteps\n",
    "            )\n",
    "\n",
    "            # Get the target for loss depending on the prediction type\n",
    "            # just the sampled noise for now.\n",
    "            target = noise  # noise_schedule.predict_epsilon == True\n",
    "\n",
    "            # Predict the noise residual and compute loss.\n",
    "            timestep_embedding = tf.map_fn(\n",
    "                lambda t: self.get_timestep_embedding(t), timesteps, dtype=tf.float32\n",
    "            )\n",
    "            timestep_embedding = tf.squeeze(timestep_embedding, 1)\n",
    "            model_pred = self.diffusion_model(\n",
    "                [noisy_latents, timestep_embedding, encoded_text], training=True\n",
    "            )\n",
    "            loss = self.compiled_loss(target, model_pred)\n",
    "            if self.use_mixed_precision:\n",
    "                loss = self.optimizer.get_scaled_loss(loss)\n",
    "\n",
    "        # Update parameters of the diffusion model.\n",
    "        trainable_vars = self.diffusion_model.trainable_variables\n",
    "        gradients = tape.gradient(loss, trainable_vars)\n",
    "        if self.use_mixed_precision:\n",
    "            gradients = self.optimizer.get_unscaled_gradients(gradients)\n",
    "        gradients = [tf.clip_by_norm(g, self.max_grad_norm) for g in gradients]\n",
    "        self.optimizer.apply_gradients(zip(gradients, trainable_vars))\n",
    "\n",
    "        return {m.name: m.result() for m in self.metrics}\n",
    "\n",
    "    def get_timestep_embedding(self, timestep, dim=320, max_period=10000):\n",
    "        half = dim // 2\n",
    "        log_max_period = tf.math.log(tf.cast(max_period, tf.float32))\n",
    "        freqs = tf.math.exp(\n",
    "            -log_max_period * tf.range(0, half, dtype=tf.float32) / half\n",
    "        )\n",
    "        args = tf.convert_to_tensor([timestep], dtype=tf.float32) * freqs\n",
    "        embedding = tf.concat([tf.math.cos(args), tf.math.sin(args)], 0)\n",
    "        embedding = tf.reshape(embedding, [1, -1])\n",
    "        return embedding\n",
    "\n",
    "    def sample_from_encoder_outputs(self, outputs):\n",
    "        mean, logvar = tf.split(outputs, 2, axis=-1)\n",
    "        logvar = tf.clip_by_value(logvar, -30.0, 20.0)\n",
    "        std = tf.exp(0.5 * logvar)\n",
    "        sample = tf.random.normal(tf.shape(mean), dtype=mean.dtype)\n",
    "        return mean + std * sample\n",
    "\n",
    "    def save_weights(self, filepath, overwrite=True, save_format=None, options=None):\n",
    "        # Overriding this method will allow us to use the `ModelCheckpoint`\n",
    "        # callback directly with this trainer class. In this case, it will\n",
    "        # only checkpoint the `diffusion_model` since that's what we're training\n",
    "        # during fine-tuning.\n",
    "        self.diffusion_model.save_weights(\n",
    "            filepath=filepath,\n",
    "            overwrite=overwrite,\n",
    "            save_format=save_format,\n",
    "            options=options,\n",
    "        )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Mixed precision compatibility check (mixed_float16): OK\n",
      "Your GPU will likely run quickly with dtype policy mixed_float16 as it has compute capability of at least 7.0. Your GPU: Quadro RTX 6000, compute capability 7.5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-12 10:27:01.000237: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.000544: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.000714: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.000952: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.056365: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.056554: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.056667: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.056826: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.056940: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-11-12 10:27:01.057028: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1613] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 20698 MB memory:  -> device: 0, name: Quadro RTX 6000, pci bus id: 0000:01:00.0, compute capability: 7.5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/gamal/anaconda3/envs/ds2f_m_s/lib/python3.8/site-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.\n",
      "Instructions for updating:\n",
      "Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089\n"
     ]
    }
   ],
   "source": [
    "# Enable mixed-precision training if the underlying GPU has tensor cores.\n",
    "USE_MP = True\n",
    "if USE_MP:\n",
    "    keras.mixed_precision.set_global_policy(\"mixed_float16\")\n",
    "\n",
    "image_encoder = ImageEncoder(image_size, image_size)\n",
    "diffusion_ft_trainer = Trainer(\n",
    "    diffusion_model=DiffusionModel(image_size, image_size, 256),\n",
    "    # Remove the top layer from the encoder, which cuts off the variance and only\n",
    "    # returns the mean.\n",
    "    vae=tf.keras.Model(\n",
    "        image_encoder.input,\n",
    "        image_encoder.layers[-2].output,\n",
    "    ),\n",
    "    noise_scheduler=NoiseScheduler(),\n",
    "    use_mixed_precision=USE_MP,\n",
    ")\n",
    "\n",
    "# These hyperparameters come from this tutorial by Hugging Face:\n",
    "# https://huggingface.co/docs/diffusers/training/text2image\n",
    "lr = 1e-5\n",
    "beta_1, beta_2 = 0.9, 0.999\n",
    "weight_decay = (1e-2,)\n",
    "epsilon = 1e-08\n",
    "\n",
    "optimizer = tf.keras.optimizers.experimental.AdamW(\n",
    "    learning_rate=lr,\n",
    "    weight_decay=weight_decay,\n",
    "    beta_1=beta_1,\n",
    "    beta_2=beta_2,\n",
    "    epsilon=epsilon,\n",
    ")\n",
    "diffusion_ft_trainer.compile(optimizer=optimizer, loss=\"mse\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def speaker_emb_preprocess(speaker_emb2):\n",
    "\n",
    "    if(ignore_speaker_embedding or ignore_speech_brain):\n",
    "        #print('ignore speech brain')\n",
    "        return np.zeros((1,768))\n",
    "    else:\n",
    "        speaker_emb2 = pickle.loads(speaker_emb2)\n",
    "        #print(speaker_emb2.print)\n",
    "        speaker_emb2 = speaker_emb2.squeeze()\n",
    "        speaker_emb2 = np.pad(speaker_emb2, (288), 'constant', constant_values=(0))\n",
    "        speaker_emb2 = np.tile(speaker_emb2, (1, 1))\n",
    "        speaker_emb2 = speaker_emb2 / 200.0\n",
    "        #print(speaker_emb2.shape)\n",
    "        #speaker_emb2 = np.array(speaker_emb2).tolist()\n",
    "        #print(type(speaker_emb2))\n",
    "        return speaker_emb2\n",
    "\n",
    "\n",
    "def audio_emb_preprocess2(speaker_emb2):\n",
    "    \n",
    "    if(ignore_pyannote_titanet_speakernet or ignore_speaker_embedding):\n",
    "        #print('ignore speech brain')\n",
    "        return np.zeros((28,768))\n",
    "    else:\n",
    "        #print(speaker_emb2)\n",
    "        speaker_emb2 = pickle.loads(speaker_emb2)\n",
    "        a = speaker_emb2 #np.zeros(shape=(24, 512))\n",
    "        a = a[-28:,:] # Actually only last 39 are the relevant ones\n",
    "        #print('au')\n",
    "        #print(a.shape)\n",
    "        b = np.zeros(shape=(a.shape[0], 768-a.shape[1]))\n",
    "        #c = np.zeros(shape=(28-a.shape[0], 768))\n",
    "        arr = np.concatenate((a, b), axis=1)\n",
    "        #arr = np.concatenate((arr, c), axis=0)\n",
    "        arr = arr / (1 if(audio_embs == 'wav2vec') else 10 if(audio_embs == 'openl3')  else 1 if(audio_embs == 'pyannoteTitaNet') else 1)\n",
    "        #print(str(arr.max()))\n",
    "        #print(arr.shape)\n",
    "        speaker_emb2 = np.array(arr)\n",
    "        return speaker_emb2\n",
    "\n",
    "def audio_features_preprocess(video_id):\n",
    "    #  79 belong to pyaudioanalysis\n",
    "    # 111 belogn to liborsa\n",
    "    if(ignore_audio_features):\n",
    "        #print('ignore speech brain')\n",
    "        return np.zeros((190,768))\n",
    "    else:\n",
    "        #print(video_id)\n",
    "        conAdditional = sl.connect(datasetPathDatabaseAdditional)\n",
    "        cur = conAdditional.cursor()\n",
    "        sql = '''SELECT AUDIO_FEATURES FROM AUDIO WHERE VIDEO_ID = ?'''\n",
    "        cur.execute(sql, [video_id])\n",
    "        audio_features = cur.fetchall()\n",
    "        #print(audio_features[0])\n",
    "        audio_features = pickle.loads(audio_features[0][0])\n",
    "        #print(audio_features.shape) # 190 x 128\n",
    "        audio_features = audio_features[0:190]\n",
    "        \n",
    "        #import sys\n",
    "        #np.set_printoptions(threshold=sys.maxsize)\n",
    "        #print(np.argwhere(audio_features == 0))\n",
    "\n",
    "        if(ignore_pyAudioAnalysis and not ignore_librosa):\n",
    "            zpa = np.zeros((190-110,128))\n",
    "            audio_features = audio_features[80:190]\n",
    "            audio_features = np.vstack((audio_features,zpa))\n",
    "            #print('ignore pyAudioAnalysis')\n",
    "            #print(audio_features.shape)\n",
    "        elif(ignore_librosa and not ignore_pyAudioAnalysis):\n",
    "            zpa = np.zeros((190-80,128))\n",
    "            audio_features = audio_features[0:80]\n",
    "            audio_features = np.vstack((audio_features,zpa))\n",
    "            #print('ignore librosa')\n",
    "            #print(audio_features.shape)\n",
    "        else:\n",
    "            audio_features = np.zeros((190,128))\n",
    "            #print('ignore pyaudioanalysis and librosa')\n",
    "\n",
    "\n",
    "        z1 = np.zeros((190,768-128))\n",
    "        audio_features = np.hstack((audio_features,z1))\n",
    "        audio_features = audio_features / 100.0\n",
    "        #print(audio_features.shape)\n",
    "    return audio_features\n",
    "\n",
    "def audio_transformer_features_preprocess(video_id):\n",
    "    #print(video_id)\n",
    "    conAdditional = sl.connect(datasetPathDatabaseAdditional)\n",
    "    cur = conAdditional.cursor()\n",
    "    sql = '''SELECT AUDIO_FEATURES FROM AUDIO_TRANSFORMER WHERE VIDEO_ID = ?'''\n",
    "    cur.execute(sql, [video_id])\n",
    "    audio_features = cur.fetchall()\n",
    "    #print(audio_features[0])\n",
    "    audio_features = pickle.loads(audio_features[0][0])\n",
    "    #print(audio_features.shape) # 514 x 768\n",
    "    audio_features = audio_features.squeeze()\n",
    "    audio_features = audio_features[0::3]#172*768\n",
    "    #z1 = np.zeros((161,768-128))\n",
    "    #audio_features = np.hstack((audio_features,z1))\n",
    "    #audio_features = audio_features / 100.0\n",
    "    return audio_features\n",
    "\n",
    "import random\n",
    "def image_guide_preprocess(face_id):\n",
    "    #print(face_id)\n",
    "\n",
    "    if(random.random() > 2):\n",
    "        image_guide = np.zeros((49,768))\n",
    "        #print(image_guide.shape)\n",
    "    else:\n",
    "        conAdditional = sl.connect(datasetPathDatabaseVgg)\n",
    "        cur = conAdditional.cursor()\n",
    "        sql = '''SELECT BLURRED_FACE_EMB FROM FACES_BLURRED WHERE FACE_ID = ?'''\n",
    "        cur.execute(sql, [face_id])\n",
    "        image_guide = cur.fetchall()\n",
    "        #print(image_guide)\n",
    "        image_guide = pickle.loads(image_guide[0][0])\n",
    "        image_guide = image_guide.squeeze() #197 x 768\n",
    "        image_guide = image_guide[1::4] #49 x 768\n",
    "    return image_guide\n",
    "\n",
    "\n",
    "#boxBlurMin =  int(configParser.get('extractVggBlurred', 'boxBlurMin'))\n",
    "#boxBlurMax =  int(configParser.get('extractVggBlurred', 'boxBlurMax'))\n",
    "\n",
    "#gaussianBlurMin =  int(configParser.get('extractVggBlurred', 'gaussianBlurMin'))\n",
    "#gaussianBlurMax =  int(configParser.get('extractVggBlurred', 'gaussianBlurMax'))\n",
    "\n",
    "\n",
    "from PIL import Image,ImageFilter\n",
    "import random\n",
    "#import cv2\n",
    "import numpy as np\n",
    "#from matplotlib import pyplot as plt\n",
    "  \n",
    "\n",
    "\n",
    "def image_guide_preprocess_low_res_dummy(path):\n",
    "    #print(face_id)\n",
    "\n",
    "    image_guide = np.zeros((1, 768))\n",
    "    return image_guide\n",
    "\n",
    "def image_guide_preprocess_low_res(path):\n",
    "    #print(face_id)\n",
    "\n",
    "\n",
    "    if(ignore_image_guide):\n",
    "        return np.nan\n",
    "    else:\n",
    "\n",
    "        image = Image.open(path).convert('RGB')\n",
    "\n",
    "        #print(image.size)\n",
    "\n",
    "        w_s = image_size / (1+2 * 0.4)\n",
    "        h_s = image_size / (1+2 * 0.4)\n",
    "\n",
    "        image = image.crop((0.2*w_s, 0.0*h_s, 1.6*w_s, 1.4*h_s))\n",
    "\n",
    "        image = image.resize((image_size,image_size))\n",
    "\n",
    "        image = image.resize((begin_with_image_size,begin_with_image_size))\n",
    "        im = image\n",
    "        \n",
    "\n",
    "        #print('saving')\n",
    "        #image.save('opop.png')\n",
    "\n",
    "        #print(np.array(image,np.float32).shape)\n",
    "\n",
    "        pix = np.array(image, np.float32)\n",
    "        #print(\"aaa\")\n",
    "        #print(pix.shape)\n",
    "        #pix = np.moveaxis(pix, -1, 0)\n",
    "        #print(pix.shape)\n",
    "        #print(\"aaa\")\n",
    "\n",
    "        pix = pix / 255\n",
    "        image.close()\n",
    "        im.close()\n",
    "        return pix\n",
    "    return image_guide\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def process_age(age):\n",
    "    if(random.random() < 0.2 or ignore_age or ignore_additional_attributes):\n",
    "        x = np.zeros(768)\n",
    "        x[767] = 1\n",
    "        return x\n",
    "    else:\n",
    "        try:\n",
    "            x = np.ones(768) * (age / 100.0)\n",
    "            x[767] = 0\n",
    "        except:\n",
    "            x = np.zeros(768)\n",
    "            x[767] = 1\n",
    "\n",
    "        return x\n",
    "\n",
    "def process_gender(gender):\n",
    "    if(random.random() < 0.2 or ignore_gender or ignore_additional_attributes):\n",
    "        return np.zeros(768)\n",
    "    elif(gender == 'man'):\n",
    "        return np.ones(768)\n",
    "    elif(gender == \"woman\"):\n",
    "        return np.ones(768) * -1\n",
    "    else:\n",
    "        return np.zeros(768)\n",
    "    \n",
    "# TODO\n",
    "def process_ethnicity(eth):\n",
    "    x = np.zeros(768)\n",
    "    if(random.random() < 0.2 or ignore_ethnicity or ignore_additional_attributes):\n",
    "        x = x\n",
    "    elif(eth == \"indian\"):\n",
    "        x[0] = 1\n",
    "    elif(eth == \"asian\"):\n",
    "        x[16]=1\n",
    "    elif(eth == \"latino hispanic\"):\n",
    "        x[2]=1\n",
    "    elif(eth == \"black\"):\n",
    "        x[3]=1\n",
    "    elif(eth == \"middle eastern\"):\n",
    "        x[4]=1\n",
    "    elif(eth == \"white\"):\n",
    "        x[5]=1 \n",
    "    else:\n",
    "        x = x\n",
    "    return x     \n",
    "\n",
    "def process_language(lan):\n",
    "    x = np.zeros(768)\n",
    "    if(random.random() < 0.2 or ignore_language_spoken or ignore_additional_attributes):\n",
    "        x = x\n",
    "    elif(lan == \"Arabic\"):\n",
    "        x[0] = 1\n",
    "    elif(lan == \"Portuguese\"):\n",
    "        x[16]=1\n",
    "    elif(lan == \"Romansh_Sursilvan\"):\n",
    "        x[2]=1\n",
    "    elif(lan == \"Japanese\"):\n",
    "        x[3]=1\n",
    "    elif(lan == \"Ukranian\"):\n",
    "        x[4]=1\n",
    "    elif(lan == \"German\"):\n",
    "        x[5]=1   \n",
    "    elif(lan == \"Chinese_China\"):\n",
    "        x[6]=1   \n",
    "    elif(lan == \"Welsh\"):\n",
    "        x[7]=1  \n",
    "    elif(lan == \"English\"):\n",
    "        x[8]=1\n",
    "    elif(lan == \"Kabyle\"):\n",
    "        x[9]=1 \n",
    "    elif(lan == \"Kyrgyz\"):\n",
    "        x[10]=1\n",
    "    elif(lan == \"Georgian\"):\n",
    "        x[11]=1\n",
    "    elif(lan == \"Persian\"):\n",
    "        x[12]=1 \n",
    "    elif(lan == \"French\"):\n",
    "        x[13]=1\n",
    "    elif(lan == \"Interlingua\"):\n",
    "        x[14]=1\n",
    "    elif(lan == \"Swedish\"):\n",
    "        x[15]=1\n",
    "    elif(lan == \"Spanish\"):\n",
    "        x[16]=1 \n",
    "    elif(lan == \"Dhivehi\"):\n",
    "        x[17]=1\n",
    "    elif(lan == \"Kinyarwanda\"):\n",
    "        x[18]=1 \n",
    "    elif(lan == \"Tatar\"):\n",
    "        x[19]=1\n",
    "    elif(lan == \"Hakha_Chin\"):\n",
    "        x[20]=1 \n",
    "    elif(lan == \"Tamil\"):\n",
    "        x[21]=1 \n",
    "    elif(lan == \"Greek\"):\n",
    "        x[22]=1\n",
    "    elif(lan == \"Latvian\"):\n",
    "        x[23]=1 \n",
    "    elif(lan == \"Russian\"):\n",
    "        x[24]=1\n",
    "    elif(lan == \"Breton\"):\n",
    "        x[25]=1\n",
    "    elif(lan == \"Catalan\"):\n",
    "        x[26]=1    \n",
    "    elif(lan == \"Maltese\"):\n",
    "        x[27]=1 \n",
    "    elif(lan == \"Slovenian\"):\n",
    "        x[28]=1    \n",
    "    elif(lan == \"Indonesian\"):\n",
    "        x[29]=1    \n",
    "    elif(lan == \"Dutch\"):\n",
    "        x[30]=1\n",
    "    elif(lan == \"Chinese_Taiwan\"):\n",
    "        x[31]=1 \n",
    "    elif(lan == \"Sakha\"):\n",
    "        x[32]=1 \n",
    "    elif(lan == \"Polish\"):\n",
    "        x[33]=1 \n",
    "    elif(lan == \"Czech\"):\n",
    "        x[34]=1 \n",
    "    elif(lan == \"Romanian\"):\n",
    "        x[35]=1 \n",
    "    elif(lan == \"Mangolian\"):\n",
    "        x[36]=1 \n",
    "    elif(lan == \"Italian\"):\n",
    "        x[37]=1 \n",
    "    elif(lan == \"Chinese_Hongkong\"):\n",
    "        x[38]=1 \n",
    "    elif(lan == \"Estonian\"):\n",
    "        x[39]=1 \n",
    "    elif(lan == \"Basque\"):\n",
    "        x[40]=1 \n",
    "    elif(lan == \"Esperanto\"):\n",
    "        x[41]=1 \n",
    "    elif(lan == \"Frisian\"):\n",
    "        x[42]=1 \n",
    "    elif(lan == \"Turkish\"):\n",
    "        x[43]=1 \n",
    "    elif(lan == \"Chuvash\"):\n",
    "        x[44]=1 \n",
    "    else:\n",
    "        x = x\n",
    "    return x       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def process_input(row):\n",
    "    #print(row)\n",
    "    age = row[\"caption_a\"]\n",
    "    ethnicity=row[\"caption_e\"]\n",
    "    gender=row[\"caption_g\"]\n",
    "    language=row[\"caption_l\"]\n",
    "    speaker_emb=row[\"SPEAKER_EMB\"]\n",
    "    audio_emb=row[\"AUDIO_EMB\"]\n",
    "    audio_features=row[\"AUDIO_FEATURES\"]\n",
    "    image_guide=row[\"image_guide\"]\n",
    "    #print(image_guide)\n",
    "    #print(speaker_emb)\n",
    "    speaker_emb = np.asarray(speaker_emb, dtype=np.float32)\n",
    "    speaker_emb = speaker_emb.squeeze()\n",
    "    audio_emb = np.asarray(audio_emb, dtype=np.float32)\n",
    "    audio_emb = audio_emb.squeeze()\n",
    "    #print(speaker_emb.shape)\n",
    "    h = np.vstack((age, ethnicity))\n",
    "    h = np.vstack((h, gender))\n",
    "    h = np.vstack((h, language))\n",
    "    h = np.vstack((h, speaker_emb))\n",
    "    h = np.vstack((h, audio_emb))\n",
    "    h = np.vstack((h,audio_features))\n",
    "    h = np.vstack((h,image_guide))\n",
    "    #print('aaaaaaaaaaa')\n",
    "    #print(h.shape)\n",
    "    j = np.zeros(768)\n",
    "    j = np.tile(j,(256-h.shape[0],1))\n",
    "    h = np.vstack((h, j))\n",
    "    #print(h.shape)\n",
    "    \n",
    "    return h\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def process_image_path(path):\n",
    "    \n",
    "    image = Image.open(path).convert('RGB')\n",
    "\n",
    "    w_s = image_size / (1+2 * 0.4)\n",
    "    h_s = image_size / (1+2 * 0.4)\n",
    "\n",
    "    #print(image.size)\n",
    "    image = image.crop((0.2*w_s,0.0*h_s,1.6*w_s,1.4*h_s))\n",
    "    image = image.resize((image_size,image_size))\n",
    "\n",
    "    #print('saving')\n",
    "    #image.save(str(random.random()) + '.png')\n",
    "\n",
    "    \n",
    "\n",
    "    #print(np.array(image,np.float32).shape)\n",
    "    pix = np.array(image,np.float32)\n",
    "    #pix = np.moveaxis(pix, -1, 0)\n",
    "    \n",
    "    pix = pix / 255\n",
    "    image.close()\n",
    "    return pix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.signal import savgol_filter\n",
    "import time\n",
    "import dask.dataframe as dd\n",
    "from multiprocessing import Manager,RLock,Value,Queue\n",
    "import ctypes\n",
    "\n",
    "class CustomDataset():\n",
    "\n",
    "    total_rows = None\n",
    "    con = None\n",
    "    lock = None\n",
    "    samples_seen =  Value('i', 0,lock=False)\n",
    "    \n",
    "    def no_of_samples_seen(self):\n",
    "        return self.samples_seen.value\n",
    "\n",
    "    def __init__(self,datasetPathDatabase_a,lock,last_sample_no):\n",
    "        self.lock = lock\n",
    "        self.samples_seen.value = last_sample_no\n",
    "        self.con = sl.connect(datasetPathDatabase_a,check_same_thread=False)\n",
    "        pass\n",
    "\n",
    "\n",
    "\n",
    "    def __len__(self):\n",
    "        \n",
    "        if(self.total_rows == None):\n",
    "            self.lock.acquire(block=True)\n",
    "            data = self.con.execute(\"SELECT COUNT(*) FROM VIDEO v \")\n",
    "            count = data.fetchall()\n",
    "            self.total_rows = count[0][0]\n",
    "            data.close()\n",
    "            print(\"Found \" + str(self.total_rows) + \" data points.\")\n",
    "\n",
    "            #data = self.con.execute(\"SELECT COUNT(*) FROM VIDEO v WHERE V.TRAINED = 1\")\n",
    "            #count = data.fetchall()\n",
    "            #data.close()\n",
    "            #self.samples_seen.value = count[0][0]\n",
    "            #print(\"Starting from \" + str(self.samples_seen.value) + \" data points.\")\n",
    "            self.lock.release()\n",
    "\n",
    "        return self.total_rows\n",
    "\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        self.lock.acquire(block=True)\n",
    "        start_time = time.time()\n",
    "        sql = (\"SELECT V.ID,F.ID,V.VIDEO_PATH, V.AGE CAPTION_A, \" + \n",
    "                            \"V.ETHNICITY CAPTION_E, \" +\n",
    "                            \"lower(V.GENDER) CAPTION_G, \" +\n",
    "                                \"A.SPEAKER_EMB, \"+ (\"A.WAV_TO_VEC, \" if(audio_embs == 'wav2vec') else \"A.AUDIO_EMB2, \" if(audio_embs == 'openl3')  else \"A.PYANNOTE_TITANET, \" if(audio_embs == 'pyannoteTitaNet') else ', ') +\n",
    "                            \"A.AUDIO_FEATURES, \" +\n",
    "                            \"A.LANG CAPTION_L, \"+\n",
    "                            \"F.FACE_PATH \"+\n",
    "                            \"FROM VIDEO V \"+\n",
    "                            \"INNER JOIN AUDIO A ON V.ID = A.VIDEO_ID \" +\n",
    "                            \"INNER JOIN FACE F ON F.ID = (select ID from FACE f2 where f2.video_id = v.ID ORDER By ID limit 1 ) \" + \n",
    "                            \"WHERE AUDIO_LENGTH = \" + audio_length_used + ' ' +\n",
    "                            \"AND V.ID in (select V2.ID from VIDEO v2 WHERE V2.TRAINED IS NULL AND AUDIO_PRE IN (3,4) AND FACES_PRE = 2 ORDER BY ABS(RANDOM()) LIMIT \"+ str(1) + \")\")\n",
    "        data = self.con.execute(sql)\n",
    "        dataGotten = data.fetchall()\n",
    "        df = pd.DataFrame(dataGotten,columns = ['ID','FACE_ID','VIDEO_PATH','caption_a','caption_e','caption_g','SPEAKER_EMB','AUDIO_EMB','AUDIO_FEATURES','caption_l','image_path'])\n",
    "        data.close()\n",
    "        \n",
    "        #print(\"aaaa\" + str(len(df)))\n",
    "        if(len(df) == 0):\n",
    "            #print(\"Trying to get items\")\n",
    "            data = self.con.execute(sql)\n",
    "            dataGotten = data.fetchall()\n",
    "            df = pd.DataFrame(dataGotten,columns = ['ID','FACE_ID','VIDEO_PATH','caption_a','caption_e','caption_g','SPEAKER_EMB','AUDIO_EMB','AUDIO_FEATURES','caption_l','image_path'])\n",
    "            data.close()\n",
    "            \n",
    "            if(len(df) == 0):\n",
    "                #print(\"Trying to get items\")\n",
    "                data = self.con.execute(sql)\n",
    "                dataGotten = data.fetchall()\n",
    "                df = pd.DataFrame(dataGotten,columns = ['ID','FACE_ID','VIDEO_PATH','caption_a','caption_e','caption_g','SPEAKER_EMB','AUDIO_EMB','AUDIO_FEATURES','caption_l','image_path'])\n",
    "                data.close()\n",
    "\n",
    "                if(len(df) == 0):\n",
    "                    #print(\"Trying to get items\")\n",
    "                    data = self.con.execute(sql)\n",
    "                    dataGotten = data.fetchall()\n",
    "                    df = pd.DataFrame(dataGotten,columns = ['ID','FACE_ID','VIDEO_PATH','caption_a','caption_e','caption_g','SPEAKER_EMB','AUDIO_EMB','AUDIO_FEATURES','caption_l','image_path'])\n",
    "                    data.close()\n",
    "\n",
    "                    if(len(df) == 0):\n",
    "                        #print(\"Reintializing dataset\")\n",
    "                        sql50 = \"UPDATE VIDEO SET TRAINED = NULL\"\n",
    "                        cur50 = self.con.cursor()\n",
    "                        cur50.execute(sql50)\n",
    "                        self.con.commit()\n",
    "                        cur50.close()\n",
    "\n",
    "                        data = self.con.execute(sql)\n",
    "                        dataGotten = data.fetchall()\n",
    "                        df = pd.DataFrame(dataGotten,columns = ['ID','FACE_ID','VIDEO_PATH','caption_a','caption_e','caption_g','SPEAKER_EMB','AUDIO_EMB','AUDIO_FEATURES','caption_l','image_path'])\n",
    "                        data.close()\n",
    "\n",
    "        data5 = np.array(df['ID']).astype('int')\n",
    "        data6 = []\n",
    "        for x in data5:\n",
    "            data6.append(int(x))\n",
    "        #print(len(data6))\n",
    "        #print(data6)\n",
    "        sql5 = \"UPDATE VIDEO SET TRAINED = 1 WHERE ID IN ({0})\".format(', '.join('?' for _ in data6))\n",
    "        #print(sql5)\n",
    "        cur5 = self.con.cursor()\n",
    "        cur5.execute(sql5, data6)\n",
    "        self.con.commit()\n",
    "        cur5.close()\n",
    "        self.samples_seen.value +=  1\n",
    "        #print (self.samples_seen.value,end='\\r')\n",
    "\n",
    "\n",
    "        self.lock.release()\n",
    "\n",
    "        \n",
    "        \n",
    "        df = df.sample(frac=1).reset_index(drop=True)\n",
    "        df = dd.from_pandas(df, npartitions=1)\n",
    "        df[\"image_guide\"] = np.nan\n",
    "\n",
    "        #print(df.head(10))\n",
    "        data_frame = df[[\"ID\",\"FACE_ID\",\"image_path\",\"caption_a\",\"caption_e\",\"caption_g\",\"caption_l\"]]\n",
    "        data_frame['SPEAKER_EMB'] = df['SPEAKER_EMB']\n",
    "        data_frame['AUDIO_EMB'] = df['AUDIO_EMB']\n",
    "        data_frame['image_guide'] = df['image_guide']\n",
    "\n",
    "        \n",
    "        data_frame['SPEAKER_EMB'] = data_frame['SPEAKER_EMB'].apply(lambda x: speaker_emb_preprocess(x),meta=('1', 'object'))\n",
    "        data_frame['AUDIO_EMB'] = data_frame['AUDIO_EMB'].apply(lambda x: audio_emb_preprocess2(x),meta=('1', 'object'))\n",
    "        data_frame['AUDIO_FEATURES'] = data_frame['ID'].apply(lambda x: audio_features_preprocess(x),meta=('1', 'object'))\n",
    "        data_frame = data_frame.drop(['ID'], axis=1)\n",
    "        data_frame['image_guide'] = data_frame['image_path'].apply(lambda x: image_guide_preprocess_low_res_dummy(x),meta=('1', 'str'))\n",
    "        data_frame = data_frame.drop(['FACE_ID'], axis=1)\n",
    "        data_frame['caption_a'] = data_frame['caption_a'].apply(lambda x: process_age(x),meta=('1', 'object'))\n",
    "        data_frame['caption_g'] = data_frame['caption_g'].apply(lambda x: process_gender(x),meta=('1', 'object'))\n",
    "        data_frame['caption_l'] = data_frame['caption_l'].apply(lambda x: process_language(x),meta=('1', 'object'))\n",
    "        data_frame['caption_e'] = data_frame['caption_e'].apply(lambda x: process_ethnicity(x),meta=('1', 'object'))\n",
    "        data_frame['low_res_image'] = data_frame['image_path'].apply(lambda x: image_guide_preprocess_low_res(x),meta=('1', 'object'))\n",
    "\n",
    "        data_frame['INPUT'] = data_frame['SPEAKER_EMB']\n",
    "        #print(data_frame)\n",
    "\n",
    "        data_frame['INPUT'] = data_frame.apply(process_input,args=(),axis=1,meta=('1', 'object'))\n",
    "\n",
    "        #for index, row in data_frame.iterrows():\n",
    "        #    x = process_input(data_frame.loc[index,\"caption_a\"],data_frame.loc[index,\"caption_e\"]\n",
    "        #                        ,data_frame.loc[index,\"caption_g\"],\n",
    "        #                    data_frame.loc[index,\"caption_l\"],data_frame.loc[index,\"SPEAKER_EMB\"],\n",
    "        #                    data_frame.loc[index,\"AUDIO_EMB\"],data_frame.loc[index,\"AUDIO_FEATURES\"],\n",
    "        #                    data_frame.loc[index,\"image_guide\"])\n",
    "        #    x = [x]\n",
    "        #    #AADFS = AADFS\n",
    "        #    data_frame.loc[index,\"INPUT\"] = x\n",
    "\n",
    "        data_frame = data_frame.drop(['caption_e', 'caption_g','caption_l','SPEAKER_EMB','AUDIO_EMB'], axis=1)\n",
    "\n",
    "\n",
    "        data_frame['image_path'] = data_frame['image_path'].apply(lambda x: process_image_path(x),meta=('1', 'str'))\n",
    "        data_frame.compute()\n",
    "\n",
    "        part = data_frame[['INPUT','image_path','low_res_image']].partitions[0]\n",
    "\n",
    "  \n",
    "\n",
    "        input0 = np.array(part['INPUT'])\n",
    "        input0 = np.array([np.array(xi) for xi in input0])\n",
    "        input0[np.isnan(input0)] = 0\n",
    "        input0[input0 > 10] = 10\n",
    "        input0[input0 < -10] = -10\n",
    "        #print(sys.getsizeof(input))\n",
    "        \n",
    "        output = np.array(part['image_path'])\n",
    "        output = np.array([np.array(xi) for xi in output])\n",
    "        \n",
    "        #print(sys.getsizeof(output))\n",
    "\n",
    "        input2 = np.array(part['low_res_image'])\n",
    "        input2 = np.array([np.array(xi) for xi in input2])\n",
    "        #print(sys.getsizeof(input2))\n",
    "        \n",
    "\n",
    "        #output = output.squeeze()\n",
    "        #print(output.shape)\n",
    "        #output = np.moveaxis(output, -2, 0)\n",
    "        #print(output.shape)\n",
    "\n",
    "    \n",
    "        \n",
    "        #print(len(procs))\n",
    "        #if(len(procs) > 0):\n",
    "        #    procs[0].join() # Wait for previous process to finish\n",
    "        #    print(\"Model trained using a batch of data...\")\n",
    "        #    prProcess,\n",
    "\n",
    "        input0 = tf.convert_to_tensor(input0)\n",
    "        #input0 = input0.to(torch.float)\n",
    "\n",
    "\n",
    "        input2 = tf.convert_to_tensor(input2)\n",
    "        #input2 = input2.to(torch.float)\n",
    "\n",
    "        output = tf.convert_to_tensor(output)\n",
    "        #output = output.to(torch.float)\n",
    "\n",
    "\n",
    "        output = tf.squeeze(output)\n",
    "        input0 = tf.squeeze(input0)\n",
    "        input2 = tf.squeeze(input2)\n",
    "        #print(output.shape)\n",
    "        #print(input0)\n",
    "\n",
    "        return {\n",
    "            \"images\": output,\n",
    "            \"encoded_text\": input0,\n",
    "        }\n",
    "\n",
    "        #return output,input0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "last_sample_no = 0\n",
    "my_file = Path(model_filename + '/last_sample_no1.picke')\n",
    "if my_file.is_file():\n",
    "    with open(model_filename + '/last_sample_no1.picke', 'rb') as handle:\n",
    "        last_sample_no = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dataset =  CustomDataset(datasetPathDatabase,RLock(),last_sample_no)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def generator():\n",
    "    for i in np.arange(my_dataset.__len__()):\n",
    "        output = my_dataset.__getitem__(1)\n",
    "        yield output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'images': <tf.Tensor: shape=(128, 128, 3), dtype=float32, numpy=\n",
      "array([[[0.39607844, 0.3137255 , 0.3137255 ],\n",
      "        [0.42745098, 0.33333334, 0.3254902 ],\n",
      "        [0.45882353, 0.35686275, 0.34117648],\n",
      "        ...,\n",
      "        [0.0627451 , 0.0627451 , 0.16470589],\n",
      "        [0.05882353, 0.0627451 , 0.16862746],\n",
      "        [0.05490196, 0.05882353, 0.16470589]],\n",
      "\n",
      "       [[0.40392157, 0.32156864, 0.31764707],\n",
      "        [0.43137255, 0.3372549 , 0.32156864],\n",
      "        [0.45490196, 0.35686275, 0.33333334],\n",
      "        ...,\n",
      "        [0.05882353, 0.05882353, 0.16078432],\n",
      "        [0.0627451 , 0.0627451 , 0.17254902],\n",
      "        [0.05882353, 0.05882353, 0.16862746]],\n",
      "\n",
      "       [[0.41568628, 0.32941177, 0.32941177],\n",
      "        [0.43137255, 0.34509805, 0.3254902 ],\n",
      "        [0.45490196, 0.35686275, 0.3254902 ],\n",
      "        ...,\n",
      "        [0.05882353, 0.05882353, 0.16078432],\n",
      "        [0.0627451 , 0.05882353, 0.17254902],\n",
      "        [0.05882353, 0.05882353, 0.17254902]],\n",
      "\n",
      "       ...,\n",
      "\n",
      "       [[0.14117648, 0.13725491, 0.15294118],\n",
      "        [0.14117648, 0.14117648, 0.14509805],\n",
      "        [0.14117648, 0.14509805, 0.14509805],\n",
      "        ...,\n",
      "        [0.11764706, 0.10588235, 0.20784314],\n",
      "        [0.11764706, 0.10588235, 0.21960784],\n",
      "        [0.11764706, 0.10588235, 0.22352941]],\n",
      "\n",
      "       [[0.14117648, 0.13725491, 0.15294118],\n",
      "        [0.14117648, 0.14117648, 0.14509805],\n",
      "        [0.14509805, 0.14509805, 0.14509805],\n",
      "        ...,\n",
      "        [0.11764706, 0.10588235, 0.21176471],\n",
      "        [0.11764706, 0.10588235, 0.21960784],\n",
      "        [0.11764706, 0.10588235, 0.22352941]],\n",
      "\n",
      "       [[0.14117648, 0.13725491, 0.15294118],\n",
      "        [0.14509805, 0.14117648, 0.14901961],\n",
      "        [0.14901961, 0.14509805, 0.14509805],\n",
      "        ...,\n",
      "        [0.11764706, 0.10588235, 0.21176471],\n",
      "        [0.11764706, 0.10588235, 0.21960784],\n",
      "        [0.11764706, 0.10588235, 0.21960784]]], dtype=float32)>, 'encoded_text': <tf.Tensor: shape=(256, 768), dtype=float64, numpy=\n",
      "array([[0.47, 0.47, 0.47, ..., 0.47, 0.47, 0.  ],\n",
      "       [0.  , 0.  , 1.  , ..., 0.  , 0.  , 0.  ],\n",
      "       [1.  , 1.  , 1.  , ..., 1.  , 1.  , 1.  ],\n",
      "       ...,\n",
      "       [0.  , 0.  , 0.  , ..., 0.  , 0.  , 0.  ],\n",
      "       [0.  , 0.  , 0.  , ..., 0.  , 0.  , 0.  ],\n",
      "       [0.  , 0.  , 0.  , ..., 0.  , 0.  , 0.  ]])>}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "output = next(iter(my_dataset))\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "metadata = {'images': np.zeros(shape=(128, 128,3)), 'encoded_text': np.ones(shape=(256, 768))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tf_dataset = tf.data.Dataset.from_generator(generator,  output_types={k: tf.float32 for k in metadata},\n",
    "    output_shapes={'images': (128, 128,3), 'encoded_text': (256, 768)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tf_dataset = my_tf_dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#i = 1\n",
    "#for count_batch in my_tf_dataset:\n",
    "#    print(i)\n",
    "#    i = i + 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "ckpt_path = model_filename + \"/finetuned_stable_diffusion.h5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ckpt_callback = tf.keras.callbacks.ModelCheckpoint(\n",
    "    ckpt_path,\n",
    "    save_weights_only=True,\n",
    "    monitor=\"loss\",\n",
    "    mode=\"min\",\n",
    ")\n",
    "#history_train = diffusion_ft_trainer.fit(my_tf_dataset, epochs=epochs, callbacks=[ckpt_callback],steps_per_epoch=2500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(model_filename):\n",
    "    os.makedirs(model_filename)\n",
    "#diffusion_ft_trainer.save_weights(ckpt_path,overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "By using this model checkpoint, you acknowledge that its usage is subject to the terms of the CreativeML Open RAIL-M license at https://raw.githubusercontent.com/CompVis/stable-diffusion/main/LICENSE\n"
     ]
    }
   ],
   "source": [
    "test_model = keras_cv.models.StableDiffusion(\n",
    "    img_width=image_size, img_height=image_size,\n",
    ")\n",
    "test_model.diffusion_model.load_weights(ckpt_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_sample = next(iter(my_dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-12 10:27:36.753386: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:428] Loaded cuDNN version 8906\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 [==============================] - 14s 95ms/step\n"
     ]
    }
   ],
   "source": [
    "generated_images = test_model.generate_image(\n",
    "    encoded_text = test_sample['encoded_text'], batch_size=1, unconditional_guidance_scale=1000\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_images(images):\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    for i in range(len(images)):\n",
    "        ax = plt.subplot(1, len(images), i + 1)\n",
    "        plt.imshow(images[i])\n",
    "        plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 128, 128, 3)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imm = test_sample['images'].numpy()\n",
    "imm = imm[ np.newaxis,...]\n",
    "imm.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_images(imm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 128, 128, 3)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generated_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_images(generated_images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'asfadsfdsf' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/home/gamal/vsc/DiffusionSpeech2Face/train_imagen_all_stable copy.ipynb Cell 27\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/gamal/vsc/DiffusionSpeech2Face/train_imagen_all_stable%20copy.ipynb#Y131sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m asfadsfdsf\n",
      "\u001b[0;31mNameError\u001b[0m: name 'asfadsfdsf' is not defined"
     ]
    }
   ],
   "source": [
    "asfadsfdsf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_loss(sample_no,loss_value):\n",
    "\n",
    "    if(UNET == 1):\n",
    "        my_file = Path(model_filename + '/loss_total_1.picke')\n",
    "        if my_file.is_file():\n",
    "            with open(model_filename + '/loss_total_1.picke', 'rb') as handle:\n",
    "                loss_total = pickle.load(handle)\n",
    "        else:\n",
    "            loss_total = []\n",
    "    else:\n",
    "        my_file = Path(model_filename + '/loss_total_2.picke')\n",
    "        if my_file.is_file():\n",
    "            with open(model_filename + '/loss_total_2.picke', 'rb') as handle:\n",
    "                loss_total = pickle.load(handle)\n",
    "        else:\n",
    "            loss_total = []\n",
    "    \n",
    "    #print(loss_list)\n",
    "    #print(loss_total)\n",
    "    loss_total.append([sample_no,loss_value])\n",
    "\n",
    "    if(UNET == 1):\n",
    "        with open(model_filename +'/loss_total_1.picke', 'wb') as handle:\n",
    "            pickle.dump(loss_total, handle)\n",
    "    else:\n",
    "        with open(model_filename +'/loss_total_2.picke', 'wb') as handle:\n",
    "            pickle.dump(loss_total, handle)\n",
    "    #print(loss_total)\n",
    "    fig = plt.figure()\n",
    "    x_val = [x[0] for x in loss_total]\n",
    "    y_val = [x[1] for x in loss_total]\n",
    "    plt.plot(x_val,y_val)\n",
    "    plt.title(\"Training Loss\")\n",
    "    plt.xlabel(\"Training Sample\")\n",
    "    plt.ylabel(\"MSE Loss\")\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "    if(UNET == 1):\n",
    "        if(os.path.isfile(model_filename + '/loss_1_plot.png')):\n",
    "            os.remove(model_filename + '/loss_1_plot.png')\n",
    "        fig.savefig(model_filename + '/loss_1_plot.png')\n",
    "    else:\n",
    "        if(os.path.isfile(model_filename + '/loss_2_plot.png')):\n",
    "            os.remove(model_filename + '/loss_2_plot.png')\n",
    "        fig.savefig(model_filename + '/loss_2_plot.png')\n",
    "    plt.close()\n",
    "\n",
    "    try:\n",
    "        fig = plt.figure()\n",
    "        plt.plot(x_val[1000::],y_val[1000::]\n",
    "                ,'.',zorder=-100)\n",
    "\n",
    "        #plt.axvline(x=1000,linestyle='--',color='green',label='1000 inner epochs')\n",
    "        #plt.axvline(x=17000,linestyle='--',color='purple',label='100 inner epochs - 100000 unique samples seen' )\n",
    "        #plt.axvline(x=23100,linestyle='-.',color='black',label='1 inner epoch - end of 1st epoch ')\n",
    "        #plt.legend(bbox_to_anchor = (1.0, 1), loc = 'upper right')\n",
    "        plt.grid()\n",
    "        yhat = savgol_filter(y_val, 1000, 3)\n",
    "        plt.plot(x_val[1000::],yhat[1000::],'r')\n",
    "        plt.title(\"Training Loss\")\n",
    "        plt.xlabel(\"Training Sample\")\n",
    "        plt.ylabel(\"MSE Loss\")\n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "        if(UNET == 1):\n",
    "            if(os.path.isfile(model_filename + '/loss_zoomed_1_plot.png')):\n",
    "                os.remove(model_filename + '/loss_zoomed_1_plot.png')\n",
    "            fig.savefig(model_filename + '/loss_zoomed_1_plot.png')\n",
    "        else:\n",
    "            if(os.path.isfile(model_filename + '/loss_zoomed_2_plot.png')):\n",
    "                os.remove(model_filename + '/loss_zoomed_2_plot.png')\n",
    "            fig.savefig(model_filename + '/loss_zoomed_2_plot.png')\n",
    "        plt.close()\n",
    "\n",
    "\n",
    "    except:\n",
    "        try:\n",
    "            plt.close()\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'imagen_pytorch'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m/home/gamal/vsc/DiffusionSpeech2Face/train_imagen_all_stable copy.ipynb Cell 29\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/gamal/vsc/DiffusionSpeech2Face/train_imagen_all_stable%20copy.ipynb#X33sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mimagen_pytorch\u001b[39;00m \u001b[39mimport\u001b[39;00m Unet, Imagen, ImagenTrainer,NullUnet\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/gamal/vsc/DiffusionSpeech2Face/train_imagen_all_stable%20copy.ipynb#X33sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mimagen_pytorch\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdata\u001b[39;00m \u001b[39mimport\u001b[39;00m Dataset\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/gamal/vsc/DiffusionSpeech2Face/train_imagen_all_stable%20copy.ipynb#X33sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m unet0 \u001b[39m=\u001b[39m NullUnet()  \u001b[39m# add a placeholder \"null\" unet for the base unet\u001b[39;00m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'imagen_pytorch'"
     ]
    }
   ],
   "source": [
    "from imagen_pytorch import Unet, Imagen, ImagenTrainer,NullUnet\n",
    "from imagen_pytorch.data import Dataset\n",
    "\n",
    "unet0 = NullUnet()  # add a placeholder \"null\" unet for the base unet\n",
    "\n",
    "unet1 = Unet(\n",
    "    dim = unet1_dim,\n",
    "    cond_dim = 512,\n",
    "    dim_mults = (1, 2, 4, 8),\n",
    "    num_resnet_blocks = 3,\n",
    "    layer_attns = (False, True, True, True),\n",
    "    layer_cross_attns = (False, True, True, True)\n",
    ")\n",
    "\n",
    "unet2 = Unet(\n",
    "    dim = unet2_dim,\n",
    "    cond_dim = 512,\n",
    "    dim_mults = (1, 2, 4, 8),\n",
    "    num_resnet_blocks = (2, 4, 8, 8),\n",
    "    layer_attns = (False, False, False, True),\n",
    "    layer_cross_attns = (False, False, False, True)\n",
    ")\n",
    "\n",
    "if(ignore_image_guide):\n",
    "    unets = (unet1, unet2)\n",
    "    image_sizes= (unet1_image_size, image_size)\n",
    "    unet_to_train = UNET #1\n",
    "    #start_image_or_video = None\n",
    "else:\n",
    "    unets = (unet0,unet1, unet2)\n",
    "    image_sizes= (begin_with_image_size,unet1_image_size, image_size)\n",
    "    unet_to_train = UNET + 1 #2\n",
    "    #start_image_or_video = input2[:1,:]\n",
    "\n",
    "#print(input2[:1,:])\n",
    "#print(input2)\n",
    "\n",
    "imagen = Imagen(\n",
    "    unets = unets,\n",
    "    image_sizes = image_sizes,\n",
    "    timesteps = timesteps,\n",
    "    cond_drop_prob = 0.1\n",
    ").cuda()\n",
    "\n",
    "\n",
    "\n",
    "trainer = ImagenTrainer(\n",
    "    imagen = imagen,\n",
    "    split_valid_from_train = False, # whether to split the validation dataset from the training\n",
    "    checkpoint_every = save_model_every,\n",
    "    checkpoint_path = model_filename,\n",
    "    max_checkpoints_keep = 1,\n",
    "    only_train_unet_number = unet_to_train\n",
    ").cuda()\n",
    "\n",
    "\n",
    "trainer.add_train_dataloader(my_dataloader)\n",
    "\n",
    "#if not os.path.exists(imagen_samples_folder):\n",
    "#    os.makedirs(imagen_samples_folder)\n",
    "\n",
    "#my_file = Path(model_filename)\n",
    "#if my_file.is_file():\n",
    "#    print('Using model file ' + model_filename)\n",
    "#    trainer.load(model_filename)\n",
    "\n",
    "#trainer.load_from_checkpoint_folder()\n",
    "#print(epochs)\n",
    "for i in range(epochs):\n",
    "    \n",
    "    loss = trainer.train_step(unet_number = unet_to_train,max_batch_size = batch_size)\n",
    "    print(f'loss: {loss}')\n",
    "    #print(\"At sample seen \" + str(my_dataset.no_of_samples_seen()))\n",
    "    plot_loss(my_dataset.no_of_samples_seen(),loss)\n",
    "    #print(loss_list)\n",
    "    #trainer.save_to_checkpoint_folder()\n",
    "    print('epoch:' + str(i+1) + ' from ' + str(epochs))\n",
    "    last_sample_no = my_dataset.no_of_samples_seen()\n",
    "    if(UNET == 1):\n",
    "        with open(model_filename + '/last_sample_no1.picke', 'wb') as handle:\n",
    "            pickle.dump(last_sample_no, handle)\n",
    "    else:\n",
    "        with open(model_filename + '/last_sample_no2.picke', 'wb') as handle:\n",
    "            pickle.dump(last_sample_no, handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 1\n",
    "ckpt_path = \"finetuned_stable_diffusion.h5\"\n",
    "ckpt_callback = tf.keras.callbacks.ModelCheckpoint(\n",
    "    ckpt_path,\n",
    "    save_weights_only=True,\n",
    "    monitor=\"loss\",\n",
    "    mode=\"min\",\n",
    ")\n",
    "diffusion_ft_trainer.fit(training_dataset, epochs=epochs, callbacks=[ckpt_callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainer.save_to_checkpoint_folder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.utils import save_image\n",
    "from torchvision.transforms import Resize\n",
    "cond_scale = random.uniform(5.1, 9.9)\n",
    "now =time.time()\n",
    "seconds = now\n",
    "output, input0 = my_dataset.__getitem__(1)\n",
    "save_image(output,'ground_truth.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resize_img_tensor = Resize((begin_with_image_size, begin_with_image_size))\n",
    "\n",
    "if(ignore_image_guide):\n",
    "    start_image_or_video = None\n",
    "else:\n",
    "    start_image_or_video = resize_img_tensor(output)\n",
    "\n",
    "start_image_or_video = torch.unsqueeze(start_image_or_video,0)\n",
    "input0 = torch.unsqueeze(input0,0)\n",
    "output = torch.unsqueeze(output,0)\n",
    "\n",
    "print(start_image_or_video.shape)\n",
    "print(input0.shape)\n",
    "print(output.shape)\n",
    "\n",
    "images = trainer.sample(text_embeds=input0,start_image_or_video = start_image_or_video,start_at_unet_number = unet_to_train\n",
    "            ,stop_at_unet_number=unet_to_train,batch_size = 1, return_pil_images = True,cond_scale=cond_scale) # returns List[Image]\n",
    "images[0].save('generated.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ds2f_m_i",
   "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.8.18"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "78dccc615e96ab04385280185a87a524fe0822daf5dbad2f4bf2e7d7b28366a7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}