testing_imagen.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",
    "    \n",
    "#import os\n",
    "#os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n",
    "#os.environ[\"AUTOGRAPH_VERBOSITY\"] = \"0\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import configparser\n",
    "\n",
    "# Loading configurations\n",
    "configParser = configparser.RawConfigParser()   \n",
    "configFilePath = r'configuration.txt'\n",
    "configParser.read(configFilePath)\n",
    "\n",
    "\n",
    "video_path =  configParser.get('test_imagen','video_path')\n",
    "\n",
    "ttwbdf =  int(configParser.get('test_imagen', 'time_to_wait_before_deleting_files'))\n",
    "\n",
    "\n",
    "cuda =  int(configParser.get('COMMON', 'cuda'))\n",
    "cpus =  int(configParser.get('COMMON', 'cpus'))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO document jupyter\n",
    "import pickle\n",
    "import sqlite3 as sl\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "from textwrap import wrap\n",
    "import os\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.options.mode.chained_assignment = None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "audio_folder = output_folder = r'imagen_testing_folder' \n",
    "if not os.path.exists(audio_folder):\n",
    "    os.makedirs(audio_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_size =  int(configParser.get('COMMON', 'resizeImageTo'))\n",
    "audio_length_used =  configParser.get('test_imagen', 'audio_length_used') \n",
    "model_filename =  configParser.get('test_imagen', 'model_filename') + '_'  + audio_length_used +  's.pt'\n",
    "openl3_mode =  configParser.get('test_imagen', 'openl3_mode')\n",
    "folder =  configParser.get('test_imagen', 'folder')\n",
    "number_of_images =  configParser.get('test_imagen', 'number_of_images')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "age =  int(configParser.get('test_imagen', 'age'))\n",
    "ethnicity =  str(configParser.get('test_imagen', 'ethnicity'))\n",
    "gender =  str(configParser.get('test_imagen', 'gender'))\n",
    "language =  str(configParser.get('test_imagen', 'language'))\n",
    "image_guide_path =  str(configParser.get('test_imagen', 'image_guide_path'))\n",
    "low_res_image =  str(configParser.get('test_imagen', 'low_res_image'))\n",
    "blur_or_pixelate =  int(configParser.get('test_imagen', 'blur_or_pixelate'))\n",
    "\n",
    "boxBlurMin =  int(configParser.get('test_imagen', 'boxBlurMin'))\n",
    "boxBlurMax =  int(configParser.get('test_imagen', 'boxBlurMax'))\n",
    "\n",
    "gaussianBlurMin =  int(configParser.get('test_imagen', 'gaussianBlurMin'))\n",
    "gaussianBlurMax =  int(configParser.get('test_imagen', 'gaussianBlurMax'))\n",
    "\n",
    "pix_to_min =  int(configParser.get('test_imagen', 'pix_to_min'))\n",
    "pix_to_max =  int(configParser.get('test_imagen', 'pix_to_max'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/media/gamal/Passport/Datasets/VoxCeleb2TestMin/Voxceleb2TestVideo/id00017/01dfn2spqyE/00001.mp4'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataGotten = [['1','1',video_path,age,ethnicity,gender,[],[],[],language,[]]]\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",
    "df[\"image_guide\"] = np.nan\n",
    "df['low_res_image'] = low_res_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>FACE_ID</th>\n",
       "      <th>VIDEO_PATH</th>\n",
       "      <th>caption_a</th>\n",
       "      <th>caption_e</th>\n",
       "      <th>caption_g</th>\n",
       "      <th>SPEAKER_EMB</th>\n",
       "      <th>AUDIO_EMB</th>\n",
       "      <th>AUDIO_FEATURES</th>\n",
       "      <th>caption_l</th>\n",
       "      <th>image_path</th>\n",
       "      <th>image_guide</th>\n",
       "      <th>low_res_image</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>/media/gamal/Passport/Datasets/VoxCeleb2TestMi...</td>\n",
       "      <td>25</td>\n",
       "      <td>black</td>\n",
       "      <td>man</td>\n",
       "      <td>[]</td>\n",
       "      <td>[]</td>\n",
       "      <td>[]</td>\n",
       "      <td>English</td>\n",
       "      <td>[]</td>\n",
       "      <td>NaN</td>\n",
       "      <td>/media/gamal/Passport/Datasets/VoxCeleb2TestMi...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  ID FACE_ID                                         VIDEO_PATH  caption_a  \\\n",
       "0  1       1  /media/gamal/Passport/Datasets/VoxCeleb2TestMi...         25   \n",
       "\n",
       "  caption_e caption_g SPEAKER_EMB AUDIO_EMB AUDIO_FEATURES caption_l  \\\n",
       "0     black       man          []        []             []   English   \n",
       "\n",
       "  image_path  image_guide                                      low_res_image  \n",
       "0         []          NaN  /media/gamal/Passport/Datasets/VoxCeleb2TestMi...  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import tensorflow as tf\n",
    "#gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "#for gpu in gpus:\n",
    "#  tf.config.experimental.set_memory_growth(gpu, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#gpus\n",
    "import pickle\n",
    "import multiprocessing\n",
    "multiprocessing.set_start_method('spawn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-10-14 12:45:07.041382: 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:  SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-10-14 12:45:07.084260: 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",
      "[NeMo W 2023-10-14 12:45:08 optimizers:54] Apex was not found. Using the lamb or fused_adam optimizer will error out.\n",
      "[NeMo W 2023-10-14 12:45:08 experimental:27] Module <class 'nemo.collections.asr.modules.audio_modules.SpectrogramToMultichannelFeatures'> is experimental, not ready for production and is not fully supported. Use at your own risk.\n",
      "/home/gamal/anaconda3/envs/ds2f_pre/lib/python3.8/site-packages/torch/functional.py:641: UserWarning: stft with return_complex=False is deprecated. In a future pytorch release, stft will return complex tensors for all inputs, and return_complex=False will raise an error.\n",
      "Note: you can still call torch.view_as_real on the complex output to recover the old return format. (Triggered internally at ../aten/src/ATen/native/SpectralOps.cpp:862.)\n",
      "  return _VF.stft(input, n_fft, hop_length, win_length, window,  # type: ignore[attr-defined]\n",
      "2023-10-14 12:45:14.312985: 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:  SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-10-14 12:45:14.349685: 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",
      "[NeMo W 2023-10-14 12:45:17 optimizers:54] Apex was not found. Using the lamb or fused_adam optimizer will error out.\n",
      "[NeMo W 2023-10-14 12:45:18 experimental:27] Module <class 'nemo.collections.asr.modules.audio_modules.SpectrogramToMultichannelFeatures'> is experimental, not ready for production and is not fully supported. Use at your own risk.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lightning automatically upgraded your loaded checkpoint from v1.2.7 to v1.9.4. To apply the upgrade to your files permanently, run `python -m pytorch_lightning.utilities.upgrade_checkpoint --file ../../.cache/torch/pyannote/models--pyannote--embedding/snapshots/17917d9c9cdff5c3c53e618a00299df26fd977aa/pytorch_model.bin`\n",
      "Lightning automatically upgraded your loaded checkpoint from v1.2.7 to v1.9.4. To apply the upgrade to your files permanently, run `python -m pytorch_lightning.utilities.upgrade_checkpoint --file ../../.cache/torch/pyannote/models--pyannote--embedding/snapshots/17917d9c9cdff5c3c53e618a00299df26fd977aa/pytorch_model.bin`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model was trained with pyannote.audio 0.0.1, yours is 2.1.1. Bad things might happen unless you revert pyannote.audio to 0.x.\n",
      "Model was trained with torch 1.8.1+cu102, yours is 2.0.1+cu117. Bad things might happen unless you revert torch to 1.x.\n",
      "Model was trained with pyannote.audio 0.0.1, yours is 2.1.1. Bad things might happen unless you revert pyannote.audio to 0.x.\n",
      "Model was trained with torch 1.8.1+cu102, yours is 2.0.1+cu117. Bad things might happen unless you revert torch to 1.x.\n",
      "d\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[NeMo W 2023-10-14 12:45:19 modelPT:161] If you intend to do training or fine-tuning, please call the ModelPT.setup_training_data() method and provide a valid configuration file to setup the train data loader.\n",
      "    Train config : \n",
      "    manifest_filepath: /manifests/combined_fisher_swbd_voxceleb12_librispeech/train.json\n",
      "    sample_rate: 16000\n",
      "    labels: null\n",
      "    batch_size: 64\n",
      "    shuffle: true\n",
      "    is_tarred: false\n",
      "    tarred_audio_filepaths: null\n",
      "    tarred_shard_strategy: scatter\n",
      "    augmentor:\n",
      "      noise:\n",
      "        manifest_path: /manifests/noise/rir_noise_manifest.json\n",
      "        prob: 0.5\n",
      "        min_snr_db: 0\n",
      "        max_snr_db: 15\n",
      "      speed:\n",
      "        prob: 0.5\n",
      "        sr: 16000\n",
      "        resample_type: kaiser_fast\n",
      "        min_speed_rate: 0.95\n",
      "        max_speed_rate: 1.05\n",
      "    num_workers: 15\n",
      "    pin_memory: true\n",
      "    \n",
      "[NeMo W 2023-10-14 12:45:19 modelPT:168] If you intend to do validation, please call the ModelPT.setup_validation_data() or ModelPT.setup_multiple_validation_data() method and provide a valid configuration file to setup the validation data loader(s). \n",
      "    Validation config : \n",
      "    manifest_filepath: /manifests/combined_fisher_swbd_voxceleb12_librispeech/dev.json\n",
      "    sample_rate: 16000\n",
      "    labels: null\n",
      "    batch_size: 128\n",
      "    shuffle: false\n",
      "    num_workers: 15\n",
      "    pin_memory: true\n",
      "    \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[NeMo I 2023-10-14 12:45:19 features:287] PADDING: 16\n",
      "[NeMo I 2023-10-14 12:45:20 save_restore_connector:249] Model EncDecSpeakerLabelModel was successfully restored from /home/gamal/.cache/huggingface/hub/models--nvidia--speakerverification_en_titanet_large/snapshots/4e0b2d387a805da7c208b13d5898ee09de8ec1e9/speakerverification_en_titanet_large.nemo.\n",
      "[NeMo I 2023-10-14 12:45:20 cloud:58] Found existing object /home/gamal/.cache/torch/NeMo/NeMo_1.18.1/speakerverification_speakernet/a8330fa516557b963a89ccbf0fcbe2f2/speakerverification_speakernet.nemo.\n",
      "[NeMo I 2023-10-14 12:45:20 cloud:64] Re-using file from: /home/gamal/.cache/torch/NeMo/NeMo_1.18.1/speakerverification_speakernet/a8330fa516557b963a89ccbf0fcbe2f2/speakerverification_speakernet.nemo\n",
      "[NeMo I 2023-10-14 12:45:20 common:913] Instantiating model from pre-trained checkpoint\n",
      "[NeMo I 2023-10-14 12:45:20 features:287] PADDING: 16\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[NeMo W 2023-10-14 12:45:20 modelPT:161] If you intend to do training or fine-tuning, please call the ModelPT.setup_training_data() method and provide a valid configuration file to setup the train data loader.\n",
      "    Train config : \n",
      "    manifest_filepath: /ws/manifests/raid/combined/train_manifest.json\n",
      "    sample_rate: 16000\n",
      "    labels: null\n",
      "    batch_size: 64\n",
      "    shuffle: true\n",
      "    time_length: 8\n",
      "    augmentor:\n",
      "      noise:\n",
      "        manifest_path: /ws/manifests/raid/musan/musan_music_noise_manifest_dur8.json\n",
      "        prob: 0.2\n",
      "        min_snr_db: 5\n",
      "        max_snr_db: 15\n",
      "    num_workers: 4\n",
      "    \n",
      "[NeMo W 2023-10-14 12:45:20 modelPT:168] If you intend to do validation, please call the ModelPT.setup_validation_data() or ModelPT.setup_multiple_validation_data() method and provide a valid configuration file to setup the validation data loader(s). \n",
      "    Validation config : \n",
      "    manifest_filepath: /ws/manifests/raid/voxceleb/small_manifest.json\n",
      "    sample_rate: 16000\n",
      "    labels: null\n",
      "    batch_size: 64\n",
      "    shuffle: false\n",
      "    time_length: 8\n",
      "    num_workers: 1\n",
      "    \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[NeMo I 2023-10-14 12:45:20 save_restore_connector:249] Model EncDecSpeakerLabelModel was successfully restored from /home/gamal/.cache/torch/NeMo/NeMo_1.18.1/speakerverification_speakernet/a8330fa516557b963a89ccbf0fcbe2f2/speakerverification_speakernet.nemo.\n",
      "e\n",
      "f\n",
      "g\n",
      "h\n",
      "i\n",
      "j\n"
     ]
    }
   ],
   "source": [
    "from testing_imagen_speechbrain import extract_speechbrain_embeddings\n",
    "from testing_imagen_pyannote_titanet import extract_pyannote_titanet_embeddings\n",
    "from testing_imagen_audio_features import extract_audio_features\n",
    "from testing_imagen_vision_transformer import extract_vision_transformer\n",
    "\n",
    "audio_embs =  configParser.get('COMMON', 'audio_embs') \n",
    "from pydub import AudioSegment\n",
    "import math\n",
    "# Get original duration of video\n",
    "audio = AudioSegment.from_file(video_path)\n",
    "audio_length_og = math.floor(audio.duration_seconds)\n",
    "\n",
    "\n",
    "video_filename = os.path.basename(video_path)\n",
    "\n",
    "absPathAudio_w = os.path.abspath(audio_folder) + \"/\" + video_filename\n",
    "absPathAudio = os.path.splitext(absPathAudio_w)[0]+'_audio.wav'\n",
    "absPathAudio_w = os.path.splitext(absPathAudio_w)[0]\n",
    "\n",
    "\n",
    "import subprocess\n",
    "# Extract audio monochannel and with 16khz and put it in absPathAudio\n",
    "\n",
    "command = \"ffmpeg -nostats -loglevel 0 -y -i '\" + video_path + \"' -acodec pcm_s16le -ab 160k -ac 1 -ar 16000 -vn '\" + absPathAudio  + \"'\"\n",
    "subprocess.call(command, shell=True)\n",
    "\n",
    "from threading import Thread\n",
    "import time\n",
    "\n",
    "# Function to delete audio temp files\n",
    "def delFiles(filesToDelete):\n",
    "    time.sleep(ttwbdf)  # wait a bit\n",
    "    for file in filesToDelete:  \n",
    "        try:\n",
    "            os.remove(file)\n",
    "        except OSError:\n",
    "            pass\n",
    "\n",
    "\n",
    "# Will either truncate or loop the original video to reach audio_length (6,12 or 24)\n",
    "audio_length_list = [24]\n",
    "for audio_length in audio_length_list:\n",
    "    path_var_len_audio =  absPathAudio_w + \"audio\" + str(audio_length) + \"s.wav\"    # path to the variable length audio\n",
    "    path_var_len_audio_temp =  absPathAudio_w + \"audio_temp\" + str(audio_length) + \"s.wav\"  # path to a temp version of the variable length audio\n",
    "\n",
    "    if(audio_length_og > audio_length):\n",
    "        # Truncate    \n",
    "\n",
    "        command = \"ffmpeg -nostats -loglevel 0 -y -ss 0 -t \"+str(audio_length)+\" -i \\\"\" + absPathAudio + \"\\\" \\\"\" + path_var_len_audio + \"\\\"\"\n",
    "        subprocess.call(command, shell=True)\n",
    "\n",
    "\n",
    "    else:\n",
    "        # Loop then truncaate\n",
    "        #print(\"lesa\")\n",
    "        twoDigitLenStr = f\"{audio_length:02}\"\n",
    "        #print(twoDigitLenStr)\n",
    "        command = \"ffmpeg -nostats -loglevel 0 -y -stream_loop -1 -i '\" + absPathAudio + \"' -t \\\"00:00:\"+twoDigitLenStr+\".000\\\" -codec:a \\\"aac\\\" -f \\\"wav\\\" -c copy '\"+ path_var_len_audio_temp + \"'\"\n",
    "        subprocess.call(command, shell=True)\n",
    "        command = \"ffmpeg -nostats -loglevel 0 -y -ss 0 -t \"+str(audio_length)+\" -i \\\"\" + path_var_len_audio_temp + \"\\\" \\\"\" + path_var_len_audio + \"\\\"\"\n",
    "        subprocess.call(command, shell=True)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    q = multiprocessing.Queue()\n",
    "\n",
    "    proc = multiprocessing.Process(target=extract_speechbrain_embeddings, args=(q,path_var_len_audio,))\n",
    "    proc.start()\n",
    "    proc.join()\n",
    "\n",
    "\n",
    "\n",
    "    df['SPEAKER_EMB'] = q.get()\n",
    "    proc = multiprocessing.Process(target=extract_pyannote_titanet_embeddings, args=(q,path_var_len_audio,audio_embs,audio_length,openl3_mode,output_folder,))\n",
    "    proc.start()\n",
    "    proc.join()\n",
    "\n",
    "    with open(output_folder + '/' + 'audio_emb_pyannote_titanet.pickle', 'rb') as handle:\n",
    "        df['AUDIO_EMB'] = pickle.load(handle)\n",
    "\n",
    "\n",
    "\n",
    "    proc = multiprocessing.Process(target=extract_audio_features, args=(q,path_var_len_audio,output_folder,))\n",
    "    proc.start()\n",
    "    proc.join()\n",
    "\n",
    "\n",
    "\n",
    "    with open(output_folder + '/' + 'audio_features.pickle', 'rb') as handle:\n",
    "        df['AUDIO_FEATURES'] = pickle.load(handle)\n",
    "\n",
    "\n",
    "    #proc = multiprocessing.Process(target=extract_vision_transformer, args=(q,output_folder,\n",
    "    #                                                                        image_guide_path,output_folder,\n",
    "    #    image_size,boxBlurMin,boxBlurMax,gaussianBlurMin,gaussianBlurMax,pix_to_min,pix_to_max,))\n",
    "    #proc.start()\n",
    "    #proc.join()\n",
    "\n",
    "\n",
    "\n",
    "    #with open(output_folder + '/' + 'image_features.pickle', 'rb') as handle:\n",
    "    #    df[\"image_guide\"] = pickle.load(handle)\n",
    "    #df[\"image_guide\"] = np.zeros((1, 768))\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    ftd = [absPathAudio,path_var_len_audio,os.path.basename(path_var_len_audio),path_var_len_audio_temp]\n",
    "    tDelete = Thread(target=delFiles, args=(ftd,))   # spawn a process\n",
    "    tDelete.start()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df3 = df[[\"image_path\",\"caption_a\",\"caption_e\",\"caption_g\",\"caption_l\"]]\n",
    "data_frame = df3\n",
    "data_frame['SPEAKER_EMB'] = df['SPEAKER_EMB']\n",
    "data_frame['AUDIO_EMB'] = df['AUDIO_EMB']\n",
    "data_frame['AUDIO_FEATURES'] = df['AUDIO_FEATURES']\n",
    "data_frame['image_guide'] = df['image_guide']\n",
    "data_frame['low_res_image'] = df['low_res_image']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_path</th>\n",
       "      <th>caption_a</th>\n",
       "      <th>caption_e</th>\n",
       "      <th>caption_g</th>\n",
       "      <th>caption_l</th>\n",
       "      <th>SPEAKER_EMB</th>\n",
       "      <th>AUDIO_EMB</th>\n",
       "      <th>AUDIO_FEATURES</th>\n",
       "      <th>image_guide</th>\n",
       "      <th>low_res_image</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[]</td>\n",
       "      <td>25</td>\n",
       "      <td>black</td>\n",
       "      <td>man</td>\n",
       "      <td>English</td>\n",
       "      <td>b'\\x80\\x04\\x95\\x8f\\x03\\x00\\x00\\x00\\x00\\x00\\x00...</td>\n",
       "      <td>b'\\x80\\x04\\x95\\x84\\x00\\x00\\x00\\x00\\x00\\x00\\x00...</td>\n",
       "      <td>b'\\x80\\x04\\x95\\x83\\x00\\x00\\x00\\x00\\x00\\x00\\x00...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>/media/gamal/Passport/Datasets/VoxCeleb2TestMi...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  image_path  caption_a caption_e caption_g caption_l  \\\n",
       "0         []         25     black       man   English   \n",
       "\n",
       "                                         SPEAKER_EMB  \\\n",
       "0  b'\\x80\\x04\\x95\\x8f\\x03\\x00\\x00\\x00\\x00\\x00\\x00...   \n",
       "\n",
       "                                           AUDIO_EMB  \\\n",
       "0  b'\\x80\\x04\\x95\\x84\\x00\\x00\\x00\\x00\\x00\\x00\\x00...   \n",
       "\n",
       "                                      AUDIO_FEATURES  image_guide  \\\n",
       "0  b'\\x80\\x04\\x95\\x83\\x00\\x00\\x00\\x00\\x00\\x00\\x00...          NaN   \n",
       "\n",
       "                                       low_res_image  \n",
       "0  /media/gamal/Passport/Datasets/VoxCeleb2TestMi...  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "\n",
    "with open(output_folder + '/' + 'filename.pickle', 'wb') as handle:\n",
    "    pickle.dump(data_frame, handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "import os\n",
    "os._exit(0)"
   ]
  }
 ],
 "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.16"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "78dccc615e96ab04385280185a87a524fe0822daf5dbad2f4bf2e7d7b28366a7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}