inference.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Execute the selected model on the provided video.\n",
    "\n",
    "The model processes 5 seconds of video (50 frames) at a time in a sliding window fashion. Then, the predictions are stored in a sequence of bar plots that can be used to render the predictions video."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "VIDEO_PATH = 'videos/Will_Smith.avi'\n",
    "MODEL_PATH = 'models/best_model.h5'\n",
    "SLIDING_STEP = 51 # number of frames to slide the window forward in the sliding window for prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-07-31 13:46:14.077118: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.078174: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.080030: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.085651: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.086863: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.088744: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.089213: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.090225: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:14.092079: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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"
     ]
    }
   ],
   "source": [
    "!export TF_FORCE_GPU_ALLOW_GROWTH=True\n",
    "gpus = tf.config.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "    # Currently, memory growth needs to be the same across GPUs\n",
    "    for gpu in gpus:\n",
    "        tf.config.experimental.set_memory_growth(gpu, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "FPS = 10\n",
    "VIDEO_WIDTH, VIDEO_HEIGHT = 100, 100\n",
    "N_CHANNELS = 3\n",
    "INPUT_FRAMES = 50 + 1  # number of frames that the model receives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_video(video_path=VIDEO_PATH):\n",
    "    cap = cv2.VideoCapture(video_path)\n",
    "\n",
    "    n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
    "    original_fps = int(cap.get(cv2.CAP_PROP_FPS))\n",
    "\n",
    "    if n_frames / original_fps < 5:\n",
    "        print(f'[!] Video should be at least 5 seconds long')\n",
    "\n",
    "    n_frames_to_keep = int(FPS/original_fps * n_frames  + 1)  # +1 is needed for frame_diff\n",
    "\n",
    "    # Select frames equally spaced\n",
    "    frames_idx = set(np.round(np.linspace(0, n_frames - 1, n_frames_to_keep)).astype(int))\n",
    "\n",
    "    frames = []\n",
    "    index = 0\n",
    "    while True:\n",
    "        ret, frame = cap.read()\n",
    "        if not ret:\n",
    "            break\n",
    "        if index in frames_idx:\n",
    "            frame = cv2.resize(frame, (VIDEO_WIDTH, VIDEO_HEIGHT)).astype(np.float32)\n",
    "            frames.append(frame)\n",
    "        index += 1\n",
    "    cap.release()\n",
    "\n",
    "    return np.array([frames[i:i+INPUT_FRAMES] for i in range(0, len(frames) - INPUT_FRAMES + 1, SLIDING_STEP)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_video = load_video()\n",
    "skeletons_video = load_video(VIDEO_PATH[:-len('.avi')] + '_skeletons.avi' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((16, 51, 100, 100, 3), (16, 51, 100, 100, 3))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raw_video.shape, skeletons_video.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-07-31 13:46:17.788982: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-07-31 13:46:18.124398: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.125627: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.127466: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.128119: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.129111: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.130938: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.131380: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.132364: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:18.134205: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.136238: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.137336: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.139205: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.139656: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.140658: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.142494: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.142939: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.143919: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 23093 MB memory:  -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:01:00.0, compute capability: 8.0\n",
      "2022-07-31 13:46:20.144278: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.146101: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 67887 MB memory:  -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:61:00.0, compute capability: 8.0\n",
      "2022-07-31 13:46:20.146325: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] 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",
      "2022-07-31 13:46:20.146748: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 2317 MB memory:  -> device: 2, name: NVIDIA T1000, pci bus id: 0000:41:00.0, compute capability: 7.5\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.models.load_model('models/best_model.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-07-31 13:46:22.151732: I tensorflow/stream_executor/cuda/cuda_dnn.cc:368] Loaded cuDNN version 8204\n",
      "2022-07-31 13:46:25.225793: I tensorflow/stream_executor/cuda/cuda_blas.cc:1786] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n"
     ]
    }
   ],
   "source": [
    "predictions = model.predict([raw_video, skeletons_video])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f18e057be80>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD7CAYAAAB68m/qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAxf0lEQVR4nO3deXjcZ3nv//c9izRaZ6zVluTYcmIndizbSRw7S2kDCRACJNDSkrRQAgm5yi9wKO2hFxzaUAJdOac90BOgCaQJBRJoIGBISqAQShuIvEXymsWRbEuyNZIlj0aLZzTL8/tj5ivLo20kzfrN/bouX5ZmRvN9EtsfPbq/z/PcYoxBKaVU8XPkewBKKaUyQwNdKaVsQgNdKaVsQgNdKaVsQgNdKaVsQgNdKaVsYsFAF5GHRWRARA7N8byIyBdF5JiIHBCRKzM/TKWUUgtJZ4b+CHDzPM+/BVif/HUP8OXlD0sppdRiuRZ6gTHmlyKydp6X3AZ83SR2KD0vIj4RWWWMOT3f+9bV1Zm1a+d7W6WUUqn27dt3xhhTP9tzCwZ6GpqBnmmf9yYfmzfQ165dy969ezNweaWUeu0QkRNzPZfTm6Iico+I7BWRvYODg7m8tFJK2V4mAr0PWD3t85bkYzMYYx40xmw3xmyvr5/1JwallFJLlIlA3wX8YXK1yzXAyEL1c6WUUpm3YA1dRB4DbgDqRKQX+DTgBjDGfAV4GrgFOAZMAO/P1mCVUkrNLZ1VLncs8LwB7s3YiJRSSi2J7hRVSimb0EBXSimb0EBXrwmBiUl+0DHr4iulbEMDXb0mPLGvl48+3sHpkXP5HopSWaOBrl4TTgVCAPSd1UBX9qWBrl4T/KPJQA9ooCv70kBXrwkDwUSgWzN1pexIA129JvRPBbrO0JV9aaAr2zPG4A+GAQ10ZW8a6Mr2Rs5FmIzGAa2hK3vTQFe2Z5Vb6ipLdIaubE0DXdmeVW7ZtnoFwVCU0VAkzyNSKjs00JXt+ZMz9CvX+AA4PaIrXZQ9aaAr2/MnA3zbah+gdXRlXxroyvb8oyF85W7W1VUCutJF2ZcGurI9fzDMymoP9VWluByiga5sSwNd2Z4/GKKh2oPTIaz0enS3qLItDXRle/5giMaqUgCafGVaQ1e2pYGubC0WNwyOhlnp9QDQ7CvTkouyLQ10ZWtnxsLEDTRUJwK9yeehfyRELG7yPDKlMk8DXdmatQZ9esklmpy1K2U3GujK1qxdolbJpclXBuhadGVPGujK1qxzXBqrz9fQQdeiK3vSQFe2NhAM4RCorSgBYFVypq6BruxIA13Zmj8YSmwocib+qld53FR7XBroypY00JWt9QfDU+UWS2Itum4uUvajga5sbSAYoqHqwkDXtejKrjTQla35gyFWeksveKzJV8apEQ10ZT8a6Mq2QpEYZyciNFbNLLkEJiKMh6N5GplS2aGBrmzL2jw0s4ae+Py0ztKVzWigK9ua2iXqnVlDB/TGqLIdDXRlW+c3Fc2soYOuRVf2k1agi8jNIvKSiBwTkU/M8vxFIvKsiLwgIgdE5JbMD1WpxbG2/afW0BuqSnFqowtlQwsGuog4gQeAtwCbgDtEZFPKy/4c+I4x5grgduBLmR6oUos1EAxR4nLgK3df8LjL6WBltUfPc1G2k84MfQdwzBjTZYyZBB4Hbkt5jQGqkx97gVOZG6JSS9MfDNFYXYqIzHiuyefRGbqynXQCvRnomfZ5b/Kx6f4SeI+I9AJPAx/JyOiUWoZEpyLPrM81+cq0FZ2ynUzdFL0DeMQY0wLcAvyriMx4bxG5R0T2isjewcHBDF1aqdn5g+EZK1wsTb4yTo+cI66NLpSNpBPofcDqaZ+3JB+b7i7gOwDGmF8DHqAu9Y2MMQ8aY7YbY7bX19cvbcRKpcEYs+AMPRIznBnTRhfKPtIJ9D3AehFpFZESEjc9d6W85iRwI4CIbCQR6DoFV3kzFo4yMRmbsWTR0pzcXKQ3RpWdLBjoxpgo8GHgGeAoidUsh0XkfhG5NfmyPwU+KCKdwGPAncYY/VlW5Y21qWjlPCUXQOvoylZc6bzIGPM0iZud0x+7b9rHR4DrMzs0pZbOWoOeetKi5XwruomcjUmpbNOdosqW/HPsErVUe9xUlbp0hq5sRQNd2VJqL9HZJBpdaA1d2YcGurKlgWCYqlIXFaVzVxV1c5GyGw10ZUv+YIiGOcotlibtXKRsRgNd2VJ/MDTnChdLk6+MsxMRJia10YWyBw10ZUsDwfCcm4oszbp0UdmMBrqynXjcMDAamnPbv0XPRVd2o4GubGd4YpJIzNBYtVANPRH4GujKLjTQle3401iyaD3vEA10ZR8a6Mp2BqxORQuUXNxOB43VHu0tqmxDA13ZTjqbiiy6dFHZiQa6sh2r5FJfOX8NHZKBPqKBruxBA13Zjj8Ypq6yhBLXwn+9m3weTgdC2uhC2YIGurIdfzA05ymLqZp9ZUzG4pwZ10YXqvhpoCvb8SebQ6ejyaubi5R9aKAr2/EHwwtu+7fo5iJlJxroylYisThD4+FFlVxAA13Zgwa6spXB0TDGpLdkEaC6zEVFiVPPRVe2oIGubOV8L9H0augiomvRlW1ooCtbsQI93ZILWJuL9KaoKn4a6MpWrObQ6ZZcQHeLKvvQQFe24g+GcDmE2oqStL+m2edhaHySUCSWxZEplX0a6MpW+oMhGqpKcTgk7a/RpYvKLjTQla0MBMM0LKLcAtMDXevoqrhpoCtb8QdDrFxkoOtadGUXGujKVvoXse3f0ljtQQRdi66Knga6so2JySijoeiiSy4lLgcNVaU6Q1dFTwNd2YbVqWixJRdIlF30XHRV7DTQlW0splNRKt1cpOxAA13Zxvnm0IuroUNiht4XOIcx2uhCFS8NdGUb6TaHnk2Tr4zJaJyh8clMD0upnNFAV7bRHwxR5nZSVepa9Nfq5iJlBxroyjasTkUi6e8StTT5ErN6DXRVzNIKdBG5WUReEpFjIvKJOV7zeyJyREQOi8i3MjtMpRY2EAwv6YYonN9c1Kc3RlURW/BnUxFxAg8AbwR6gT0isssYc2Taa9YDnwSuN8acFZGGbA1Yqbn0B0NsW+1b0td6y9yUlzh1hq6KWjoz9B3AMWNMlzFmEngcuC3lNR8EHjDGnAUwxgxkdphKzc8Ys6jm0Km00YWyg3QCvRnomfZ5b/Kx6TYAG0TkORF5XkRunu2NROQeEdkrInsHBweXNmKlZhE8FyUcjS+55AJ6Lroqfpm6KeoC1gM3AHcAD4mIL/VFxpgHjTHbjTHb6+vrM3RppZa3qcjS7PNoDV0VtXQCvQ9YPe3zluRj0/UCu4wxEWNMN/AyiYBXKif8GQj0Jm8ZZ8bC2uhCFa10An0PsF5EWkWkBLgd2JXymu+TmJ0jInUkSjBdmRumUvObag69zJILQP+IztJVcVow0I0xUeDDwDPAUeA7xpjDInK/iNyafNkzwJCIHAGeBT5ujBnK1qCVSjXVHHqJN0VBNxep4pfWljpjzNPA0ymP3TftYwP8SfKXUjnnD4bxlrnxuJ1Lfo/za9E10FVx0p2iyhaW0qkoVaO3FBFtRaeKlwa6sgV/MLSscgtAqctJfaU2ulDFSwNd2YJ/Gdv+p2vSRheqiGmgq6IXixsGx8LLLrnA+XPRlSpGGuiq6A2NhYnFzZK3/U/X5PNwShtdqCKlga6Knj/Z2GKxzaFn0+QrIxSJc3Yisuz3UirXNNBV0cvEpiKLrkVXxUwDXRW9TJzjYtG16KqYaaCrojcQDOEQqKssWfZ76QxdFTMNdFX0/MEwdZWluJzL/+u8otyNx+3QQFdFSQNdFb3+YCgj5RY43+hCSy6qGGmgq6K3nE5Fs0msRdft/6r4aKCrojcwmpldopYmr3YuUsVJA10VtXA0xvD4ZGYD3VfG4GiYcFQbXajiooGuitpAclNRJksuTb7ENwdtdKGKjQa6KmoDo5lbg27RteiqWGmgq6LWP2LN0DNbcgE9Fz0X9h4fZmgsnO9h2IYGuipqmdz2b1npTbyX3hjNrnOTMX7/oXa++LNX8j0U29BAV0XNPxqixOnAV+7O2Ht63E7qtNFF1h0+NcJkLE5H70i+h2IbGuiqqPlHEp2KRCSj79vs82gNPcs6egIAHD0dZDIaz+9gbEIDXRU1fzAzjS1SNfl0LXq2WYE+GY3zsn80v4OxCQ10VdT8o5nb9j9dItBD2ugiizp7A1zeVA3AwT4tu2SCBroqalbJJdOafGWci8QIaKOLrBgaC9MzfI5btzbhLXNzQOvoGaGBrorWWDjK+GQsKyWX5uTmIq2jZ0dnbwCAbat9bGnxcrAvkNfx2IUGuipa/gw2tkil56JnV8fJAA6Bzc1e2pq9vNQ/SiiiRy0slwa6Klr+5Nb8bJVcQAM9Wzp6R9jQWEVFqYstLV4iMcOL/XpjdLk00FXR8o9mflORpbaihBKXg1N6nkvGGWPo7AmwbbUPgLaWxO8Hk2UYtXQa6Kpo+ZMHczVkIdBFJHkuus7QM+340AQj5yJTgd7k9VBbUaI3RjNAA10Vrf6REJWlLipLXVl5/yafR0suWdCZXH++NRnoIkJbi1eXLmaABroqWgOjme1UlEobXWRHR0+AMreT9Q2VU49tafbysn+Uc5N6Y3Q5NNBV0fIHM9upKFWTr4yB0bBuS8+wjp4AbS3eC5p6t7X4iBs4clpn6cuhga6KVv9IdnaJWpp9ZRhzfnmkWr7JaJwjp4JT9XPLlhYvgNbRlymtQBeRm0XkJRE5JiKfmOd1vyMiRkS2Z26ISs1kjEmWXLI7QwfdXJRJR08HmYzF2Zpc2WJprPbQWF3KQQ30ZVkw0EXECTwAvAXYBNwhIptmeV0V8FGgPdODVIXvV6+e4ez4ZM6ud3YiQiRmsltD9+m56Jk2tUP0It+M59qafVPPq6VJZ4a+AzhmjOkyxkwCjwO3zfK6zwJ/B+jPp68xZ8cnec9X2/mnnx/L2TWtfp+5mKFroGdOR0+AuspSmrwz/9y2tHjpOjPOaEjPz1mqdAK9GeiZ9nlv8rEpInIlsNoY81QGx6aKRHv3MHED7d1DObumPwu9RFN53E5qK0ro01Z0GdOR3FA02/n1bS1ejIHDp4J5GJk9LPumqIg4gH8A/jSN194jIntFZO/g4OByL60KhBXkR04HGTmXm9nVwNQ5LtkruYCei55JI+cidA2Os221d9bn25oTj2sdfenSCfQ+YPW0z1uSj1mqgM3AL0TkOHANsGu2G6PGmAeNMduNMdvr6+uXPmpVUNq7hqn2uDAG9p0Yzsk1rebQDVXZm6GDbi7KJCuot6ascLHUVZbS7CvjgG4wWrJ0An0PsF5EWkWkBLgd2GU9aYwZMcbUGWPWGmPWAs8Dtxpj9mZlxKqgjExEONof5D3XrMHtFNq7chPo/tHQ1Hkr2WTN0LXRxfJ19JwFYEvKCpfp2pq9eqbLMiz4r8EYEwU+DDwDHAW+Y4w5LCL3i8it2R6gKmy7jw9jDPzWhnq2tvho785NoA8EQ1k5wyVVs6+M8ckYwXPRrF/L7jp6RlhXX4G3bO6G3m0t3sRZL9pYZEnSmt4YY542xmwwxlxsjPmr5GP3GWN2zfLaG3R2/trR3jVEicvB1tU+drTWcLBvhPFw9sOvP5jdbf8WXYueGcaYqRui87HWpx86pWWXpdCdompZ2ruHuWK1D4/byc51tcTihv0nz2b9utlqDp1Kly5mxqmREGfGwgsGunVjVNejL40GulqyYCjC4VMj7FxXC8BVa1bgdGS/jh6NxTkzFs5JyWVqc9GIBvpyTJ2wOE/9HMBb7mZNbbmudFkiDXS1ZPuOnyVu4JrWGgAqS11sbqpmd5br6INjYYzJ/pJFgLqKUkqcDi25LFNHT4ASp4ONq6oXfG1bs1fPdFkiDXS1ZM93D+F2CldctGLqsR2tNXT0BLLaH9JqbJGLkovDIazyeTilm4uWpaMnwKam6rRWJW1p8dIXOMfQWDgHI7MXDXS1ZO1dw2xt8VFW4px6bGdrLZOxOB3JH7GzIZvNoWej56IvTzQW52DvyIL1c0tbc+J12vBi8TTQ1ZKMhaMc7BvhmmT93HL12hpEyGod3Qr0bDSHno3uFl2eVwbGOBeJpR3om5sTZRmtoy+eBrpakn0nzhKLG3auq7ngcW+5m8tWVrP7ePbOdfEHQzgdQl1FbgK9eUUZ/mCISEwbXSxFasu5hVR53Kyrr9Ado0ugga6WpL1rCJdDuGrNihnP7WytYd+Js1nr9OMPhmmoKsXhmHnAUzY0+zzEtdHFknX0BPCWuVlbW57212xp9uoMfQk00NWStHcP09bipbxkZoPmna01hCLxrNVA/TnaJWo5vxZdA30pOnoCbJ3jhMW5bGnx0R8MTR3CptKjga4W7dxkjAO9AXa21s76/NXJZYzZOk7XHwyxMkf1c9DNRcsxMRnlZf8o21pmP2FxLtqSbmk00NWi7T95lkhsZv3cUldZyiUNlVlbj57t5tCpmry6/X+pDvaOEDezdyiaz6amahyC1tEXSQNdLVp71xAOge2z1M8tO1pr2Hv8LNEM30gMRWKMnIvkNNDLSpzUVJToDH0JrC38C+0QTVVe4mJ9Q5WevLhIGuhq0Z7vHmZzs5cqz9yn5u1srWEsHOXo6dGMXjvXa9Atei760nT0BFhdU0Zt5eJLZG0tXg72jejRxYugga4WJRSJ0dETYGfr7OUWi1Vfz3Qd3dolmott/9MlNhfpDbrF6uwZWfTs3LKlxcuZsUlOj+j/93RpoKtFeeFkgMlofMaGolQrvR7W1JZn/Hz0/rzN0HVz0WINjIboC5xLe0NRKuvkRb0xmj4NdLUo7d1DiMD2tfPP0AF2rK1hz/Fh4vHM/cg8kKdAb/aVMRqOEtSO9Gnr7EkE8VIDfeOqalwO4WBfIHODsjkNdLUo7V3DbFpVPW/XGcvOdbUEJiK8PJC5Oro/GMLjdlDtmbn+PZt06eLidfYEcDqEy5sWt2TR4nE7uXRllc7QF0EDXaUtHI2x/+TZOdefp7Lq7JlcvtifXLK4mE0qmTB1LroGeto6ewNc2lh1weFti7VFb4wuiga6StuB3hHC0fic689Ttawoo8nryehBXf5gKOflFkiUXAD69MZoWuLxZMu5Ra4/T9XW7CMwEaFnWL+RpkMDXaWtvSuxYmVHGvVzABFhR2sN7d3DGZthDeQp0OsqS3E7RWfoaeoeGmc0FGXbEle4WKZ2jGodPS0a6Cpt7d3DXLayihUVJWl/zY7WWs6Mhek6M77s6xtjEs2hq3K7ZBGSjS70XPS0dZwMAIvfIZpqQ2MVJU6HHtSVJg10lZZILM6+E2cXXH+eyirPZKKOHgxFCUXirPTmfoYOurloMTp7A1SUOLm4vnJZ71PicrBxld4YTZcGukrLwb4RJiZjC64/T7WuroK6ytKpcs1yDEw1tshXoOvmonR19gRoa/HizMARx20tXg71jWR0+atdaaCrtDxv1c8XOUMXEXZmqI4+takoDyUXSNwY7Q+GMn4+jd2EIjGOnA6ybfXcZ/0sxpZmH6PhKMeHll+2szsNdJWW9q5h1jdULulMjh2tNZweCdF7dnnliqnm0HkruZQRixv8o9q8eD5HTweJxAzbVi9t/XmqtuSNUe0xujANdLWgaCzO3uPDaS9XTGV93XKPAcjXwVwW3VyUHqtBeKZm6OsbKvG4HVM7T9XcNNDVgg6fCjI+GUt7Q1GqDQ1V+Mrdy66j+4MhvGVuPO6lb1RZjmbdXJSWzp4AjdWlGftJyuV0cHmTV48ASIMGulqQdWLiUmfoDodw9doadh9f/gw916csTrdKG12kpbN36ScszqWt2cuhviAxvTE6Lw10taD2rmHW1VXQULX0GdfO1hpODE3Qv4yjUPtz3KkoVUWpC1+5W2fo8whMTNJ9ZnzZ689TbWnxci4S49XBsYy+r91ooKt5xeKG3cuon1sycT56vnaJTqfnos+vM7lefLk7RFNpj9H0aKCreR09HWQ0FF1y/dyycVUVlaWuJd8YjccNA6PhvJZcQM9FX0hnTwCR8ytTMqW1rpKKEqe2pFuABrqal7X+fLkzdJfTwfa1K5a8Y/TMeJhY3OR9ht7s82gNfR4dPQEuqa+ctz3hUjgdwuXNXm0avYC0Al1EbhaRl0TkmIh8Ypbn/0REjojIARH5mYisyfxQVT60dw+zprZ86obgcuxoreHYwBhnxha/jntgqvVcnksuvjJGQ9roYjbGGDp7AmxdYkOLhWxp9nLkVJCIbuya04KBLiJO4AHgLcAm4A4R2ZTysheA7caYLcATwN9neqAq9+Jxw57jw4s+v2UuVtlmzxJm6fleg26x1qKf1jr6DL1nzzE0PrnkDkUL2bLaRzga52V/ZhuP20k6M/QdwDFjTJcxZhJ4HLht+guMMc8aYyaSnz4PtGR2mCofXvKPEpiILLt+bmlr9uJxO5ZURz/fSzT/NXTQteizOb+hyJeV99+S7DGqJy/OLZ1AbwZ6pn3em3xsLncB/76cQanC0J6h+rmlxOXgqjUrlhTo/mAYEahfwtEDmXS+0YUGeqrOngClLgeXrqzKyvuvqS2nyuPSOvo8MnpTVETeA2wHPj/H8/eIyF4R2Ts4OJjJS6ssaO8eptlXRsuK8oy95461tbzYH2RkYnE16IFgiLrKUlzO/N7Hr68qxeXQRhez6egJsLnZiztLf0YikmhJpzP0OaXzf74PWD3t85bkYxcQkZuATwG3GmNmvetljHnQGLPdGLO9vr5+KeNVOWKMYXf38tefp9q5rgZjYM8id43253mXqMXpEFZ69Vz0VJFYnEOnMr9DNFVbs48X+4OEo7GsXqdYpRPoe4D1ItIqIiXA7cCu6S8QkSuAfyYR5gOZH6bKtWMDYwyNT3JNhurnlm2rfZQ4HYveYOQPhlmZ5xuiFj0XfaaX/aOEIvGM7xBNtaXFSyRmeKlfb4zOZsFAN8ZEgQ8DzwBHge8YYw6LyP0icmvyZZ8HKoF/E5EOEdk1x9upIvF8ss6d6Rm6x+1k22rfotejDwRDeWtskarZV6Y19BRTN0SzPkPXHaPzcaXzImPM08DTKY/dN+3jmzI8LpVnz3cNscrr4aKazNXPLTtaa/jyf77KWDhKZenCfwXD0RhD45M0LuMsmUxq8nnoD4aIxU1GOvLYQWdPgJqKElbXLH+/wnxaVpSxotytdfQ56E5RNYMxhvauxPpzkcwH1s51NcTihn0nzqb1+sFRq7FF/mvocL7RxcColl0sHT0BtrZ4s/L3ZToRoa3Fpytd5qCBrmboOjPOmbEwOxfZPzRdV160AqdD0j4f3epUVCglF12LfqGxcJRXBsaytkM01dYWLy/7Rzk3WXw3Riejce75+t6M9NidjQa6mqG9K1k/z9AO0VQVpS7amr1p19GndokWSMnl/Fp0naFDYqOPMeQs0NuavcTihiOngzm5XiY9/Fw3PzniZ3wympX310BXM7R3D1FfVUprXUXWrrGztYbO3kBasywr0PPVSzTVKq92LpouVzdELVuS1ym2kxdPBc7xhf94hTduauQNlzVm5Roa6OoC2a6fW3auqyESM7zQs3Ad3R8M43YKK8oze4LfUlV53FR7XBroSZ09AdbUlrOioiQn12usLqW+qrTo6uj3//AIBsOn3556FFbmaKCrC5wcnqA/GMpa/dxy1ZoaRM6Xd+bjD4ZoqPJk/YbbYui56Od19gaydn7LbESELc3FtWP0Fy8N8OPD/XzkDeszuvM6lQa6uoAVsNdkqX5u8Za52bSqOq06uj8YKphyiyWxFl1r6P5giNMjoazvEE3V1uLl2OAY4+Hs1KIzKRSJ8eldh1lXX8Hdr2vN6rU00NUFnu8eoraihEsaKrN+rR2tNew/eXbBbdz5bg49G52hJ1j181zdELVsafFiDBw+Vfg3Rr/yn69yYmiCz962mVKXM6vX0kBXF2jvSpzfkovyxs7WWsLR+II/OvuD4WU1qM6GJl8ZI+cijBXBDDGbOnoCuBzC5U3VOb1uW7MPgAMFfmP0xNA4X/rFq7xtyyquv6Qu69fTQFdTeoYn6Aucy9j55wvZkSzrzHec7lg4ylg4WnAllyZfYjynX+Oz9M6eABtXVeNxZ3fmmaq+qpQmr6egjwAwxvCXuw7jdgh//tbs3QidTgNdTWnP0vktc6mpKGFDY+W8gT5QII0tUllr0Xtfw4EejxsO9I7k9IbodG0tXg4W8EqXnxzx8+xLg3zsjRtyNiHRQFdT2ruG8JW72dCQnQYFs9nRWsO+48NE5+gT2V9gm4osF9dX4nE7+PyPXyIwMZnv4eTFq4NjjIWjOa+fW7a0+Og+M87IucLr7zoxGeUzuw5z2coq7rxubc6uq4GuprR3D7NjbQ2OHB44tbO1lvHJ2Jw3t6aaQxdYyWVFRQn//N7tHBsY4w8f3l2QoZJt51vOefNyfevkxcMFOEv/p58f49RIiM++Y3NOm7JooCsATo+c4+TwRNbXn6faOVVHn/1si0JpDj2b39pQz1feeyVHTwe58192Mxp6bYV6R0+AqlIX6+qyvyJqNlNH6RZYoB8bGOOr/9XF71zZwtVrc1O+tGigKyD757fMpaHaQ2tdxZzr0fuDISpKnGkds5sPb7iskQd+/0oO9o7wgUf2FMW66Ezp7A2wZbU3pz/RTbcieVxvIW0wMsZw3w8OUeZ28slbLsv59TXQFZCYIVd5XGxcldvlZwA71tawu3uYWNzMeG4gGC64ckuqN12+ki/ecQX7Twa469E9RXkK4GKFIjFePD2a8w1FqbY0+zjQF8jrGKbb1XmKX706xMdvvoy6PDQ010AvcMYYvvSLY9zz9b0Mj2fv5tvzyfNb8tGwYee6GoKh6KxtxfzBUMHdEJ3NLW2r+Iff28ru7mE++PW9hCL2DvXDp0aIxk3eVrhY2lq89Ayf42wW/22kazQU4a+eOsqWFi+/v+OivIxBA72AxeOGz/zwCH//45f4yRE/v/PlX3FiaDzj1xkIhug+M56z9eeprPXou2epoxdKc+h03Latmb9/11aee/UMf/SNfbZuZNzRkyhz5DvQtxRQHf0ff/oKg2NhPnvb5rx1stJAL1DRWJyPP3GAR351nA9c38q//dG1BCYmeeeXfsX+k+l1+klXtvqHpqtlRTnNvrIZ69GNMUVRcpnuXVe18DfvbOMXLw1y7zf3MxmdfTlmsevsCdDk9eS96cjmlkSg5/so3SOngjz66+PcseOivC3jBA30ghSOxrj3W/v57v5ePnbTBv7ibRu5em0N3/3QdVSWurjjwef58aH+jF2vvWuIylIXm/JQP7fsbE3U0Y05X0cPTESYjMWLouQy3e07LuKz79jMfxwd4COP7Scyxxr7YtbRE8hrcFmqPW7W1VXkdcdoPG74ix8cwlvm5s/efGnexgEa6AVnPBzl7kf38sxhP/e9bRMfvWn91Lkq6+orefL/u46Nq6r50Df38fB/d2fkmu3dw2xfuyKn62VT7VxXw9D4JK8Ojk091l/ASxYX8t5r1vDpt2/imcN+Pvbtjjk3ThWj4fFJTg5PFESgQ/53jD6xv5d9J87yibdchq88N2fCz0UDvYCMTER4z9faee7YGf73727lA78x86jN2spSHvvgNbxpUyP3/+gI9//wyKyrQ9J1ZizMsYGxvNXPLTuS159edjnfqag4auip3n99K5+6ZSM/OnCajz9xYFl/ToWkc2pDkS+v47C0NXs5PRLKS9PuwMQkf/vvL3LVmhW868qWnF8/lQZ6gRgYDfHuB3/N4b4gX/qDK3nXVXP/5SgrcfKlP7iK91+/loef6+beb+5f8qqK3Xmun1vW1pbTUFV6QcMLa5dooZ20uBgf/M11fPzNl/LkC3184rsHiNsg1Dt6Ajjk/MaefLNa0h3Kwyz9888kjn747G2b87YefzoN9ALQe3aC3/vKrzkxNMHX7tzOzZtXLfg1Tofw6bdfzn1v28QzR/q546HnGRoLL/ra7V1DlJc48/6PU0TYkVJHt0ouDUWyymUu977+Ev74pvX8275ePvX9QxfcJyhGnb0BNjRWUVEgm70ub6pGhJzX0Tt7Anxr90ned91aNuX4+OC5FMafyGvYsYEx3vu1dsbDUb5x9w6uWrO4mfIHfqOVJl8ZH338BX77y7/ikffvWFRz5/buYa5aswJ3Huvnlp3ravnRgdOcHJ5gTW0F/mCImoqSrDcFyIWP3rieSCzOA8++itspfObWy7N25vxAMMSuzlN8v6OPvrPneN36em7c2MANGxrwLrMvqzGGzp4Ab9q0MkOjXb6KUheX1FfmdMdoLG748+8for6ylD9544acXXchGuh5dKhvhD98eDcOgcfvuXbJ3+Vv3rySx+65hrsf3ctvf+k5vvq+7Wl9Yxgen+TF/lHevrVpSdfNtJ3TzkdPBHqYhqrinp1bRIT/+aZLicQMD/6yC5fDwV+8bWPGQn08HOWZw/08+UIfzx07Q9wkuvrccGkDv3x5kF2dp3A6hKvXruCmjY3cuLFxUd/4LSeHJzg7ESmYG6KWthYv//XKGYwxOWnO8q3dJznYN8IXbt9GlacwmpeDBnre7O4e5q5H9lBd5uYbd+9c0j+u6a68aAXf+9B1vP+RPdzxUDv/993buKVt/tLNVP08x+e3zGV9QyU1FSW0dw3ze9tXJ1vPFW/9PJWI8Mm3XMZkNM7Dz3XjdgmfuPmyJQdQNBbnv4+d4fsv9PHMYT/nIjFaVpRx7+sv4bZtzVNtBGNxQ0dPgJ8d9fOzowN87qmjfO6po6yrr+CNyXC/8iJfWqucOgrshqhla4uP7+3voz8YYpW3LKvXOjMW5vM/fpFr19Vya4FMhiwa6Hnwi5cG+KNv7KPJV8Y37tpJky8zfwHX1lXw3Q9dxwe/vpd7v7WfT92ykbt+o3XOwGjvHsLjdkzdVMo3kcQMcvfxxI5RfzCU17Xx2SAifPrtm4jG4/zzf3ZR6nTwJ29Kf+2yMYZDfUG+90IvP+w8xZmxSbxlbt55ZTPvvKKZqy5aMePmnNMhXLVmBVetWcGf3XwZPcMTiXB/cYCHn+vmn3/Zha/czesvbeDGjQ385oZ6queYdXb0BPC4HWxozM8Ji3NpS24wOtA7kvVA/5unX+RcJMZn35G9stlSaaDn2I8OnOJj3+5gQ2MVj35gR8YP8KmpKOGbd+/kY9/u4HNPHaVneIL73n75rFuR27uGufKiFZS48l8/t+xsreWZw356hic4MxYumm3/iyEi3H/rZqIxwxd/fgyX08H/uHH9vF/TMzzBDzr6ePKFPl4dHKfE6eDGjQ2844pmbri0flH3GVbXlHPn9a3ceX0ro6EIv3z5DD876ufZlwZ48oU+XA5h57oabryskZs2NnJRbfnU13b2BGhr9uZ1z8JsNq2qxukQDvaO8ObLs1ff33N8mO/u7+VDN1zMJTlsBJMuDfQcenz3ST755EG2r1nB1+68es5Z0HJ53E4e+P0r+Zt/P8pD/9XNqZEQX7z9CspKzv+jH5mIcLQ/yB/fWDg3dOD8uS5PHTxN3JD3reXZ4nAIf/3ONiIxwz/89GXcTgcfuuHiC14zMhHhqYOnefKFXvYcTxz3sKO1hrtft45bNq9a9g1OgCqPm7duWcVbt6wiFjfsP3mW/0iWZu7/0RHu/9ERNjRWcuPGRl5/aQOHTgV537Vrln3dTPO4nWxorMrqmS6RWJw/f/IQzb4yPvKGS7J2neXQQM+Rh37ZxV89fTTRFOE9V10QrtngcAifeusmWlaU85kfHub2h57na+/bPvUTwZ7jwxiT//XnqTauqqbK42JXxykAVto00CHxZ/T379pCNB7n7378Im6n8N5r1/Dsi4mZ8rMvDjIZi3NJQyUff/Ol3LatiZYV5Qu/8RIlbprWcPXaGj75lo0cPzM+Fe4P/rKLL//iVYCCuyFq2dLs5SdH+rN2Y/TRXx3nJf8oX3nPVZSXFGZ0FuaobMSYxAzsn35+jLe2reIf370tpyWO9123liZfGR95bD/v/NJzPPL+HVxcX0l79xAlLkfB3dyyQuXnLw4AxbntfzGcDuH//O5WIrE4n3vqKF/4j1cYDUepqyzlvdeu4Z1XNCfXWee+Vru2roK7X7eOu1+3jpFzEf7z5UGOng7yhssacj6WdLS1ePn23h56z55jdU1mv/H1j4T4x5++zA2X1vPmyxsz+t6ZlFagi8jNwBcAJ/BVY8zfpjxfCnwduAoYAt5tjDme2aEWn8Txt4d59NcnePf21fz1b7fl5VjNN25q5PF7ruXuR/fwO1/+FQ/94Xbau4fZttqHx114a7x3tE4PdPvV0FO5nA6+cPsVeMsOE47EeMcVzVx3cW1B1am9ZW5u3dpUcKs6pttinbzYN5LxQP/cU0eIxE1W9w9kwoKBLiJO4AHgjUAvsEdEdhljjkx72V3AWWPMJSJyO/B3wLuzMeD5hKMxxsMxxkJRRsORxMfhCGPJx6Z/PB6OMhaOMhqOEpqM4S13U19VSkNVafJ3D/XJj+srSxc9q7aOv33yhT4++LpW/tctmVtzvBTbVvv43oeu585HdvMHD7UTjcf58OsLsw5oLaN0OoTaPHR9yQe308Hf/HZbvodR1C5dWYXbKRzoHVlwye5i/PcrZ/jRgdP88U3rWVO7vOXF2ZbODH0HcMwY0wUgIo8DtwHTA/024C+THz8B/D8REZOFPc4/PnSab+/pYSwcTYRzOJIM6BiTaZ5oV1HipNLjoqLURVWpi1K3k5NDE+w7cXbOrkC+cvdU2NdXltJQ7Un+nvjc+iZQXeYiHI3zkcde4KdH/PzPN23g3tdfUhDf1S+qLed7yWWNe46f5dqL6/I9pFltbvZSXuKk2uPOW6MAVXxKXU4uW1nNE/t6eLE/SInTQYkr8avU5Zj6vNTlnHp8tteUuh2UOM+/5r4fHGJNbTl/9FsXLzyIPEsn0JuBnmmf9wI753qNMSYqIiNALXAmE4OcbiwcY2h8kooSFy0rSqgsraKyNBnOHlcyrN1UlroSvzwuKkudVJa6qSh1UlHimvcQnUgszpmxMIOjYQaCYQatj0dDyd/D7D1xloHR8KzNC0pcDspLnAQmInzm1st533VrM/2/YFl85SX861076ewJTK0oKTRup4PrL6l7TfTmVJn1/uvX8q32kwyPTzIZjTMZjRNO/pqMJiZ9k9E4iz0j7V/ef3VBlidTyUKTaBF5F3CzMebu5OfvBXYaYz487TWHkq/pTX7+avI1Z1Le6x7gHoCLLrroqhMnTmTyvyWnjDEEQ9ELwn7q11iYN21qTOuQLTW78XCUuDEFta1a2Uc0Fp8Kdyv0J2NxwpELH5+Mxaiv9ExtXCoEIrLPGLN9tufSmaH3Aaunfd6SfGy21/SKiAvwkrg5egFjzIPAgwDbt28v6iPnRARvmRtvmXtqi7XKnEI5yU/Zk8vpwOV0kOd+FBmXzp2+PcB6EWkVkRLgdmBXymt2Ae9Lfvwu4OfZqJ8rpZSa24LToGRN/MPAMySWLT5sjDksIvcDe40xu4CvAf8qIseAYRKhr5RSKofS+rnWGPM08HTKY/dN+zgE/G5mh6aUUmoxCmfnglJKqWXRQFdKKZvQQFdKKZvQQFdKKZvQQFdKKZtYcKdo1i4sMggsdatoHVk4ViDDCn2MhT4+0DFmQqGPDwp/jIU2vjXGmPrZnshboC+HiOyda+troSj0MRb6+EDHmAmFPj4o/DEW+vim05KLUkrZhAa6UkrZRLEG+oP5HkAaCn2MhT4+0DFmQqGPDwp/jIU+vilFWUNXSik1U7HO0JVSSqUoukAXkZtF5CUROSYin8j3eKYTkdUi8qyIHBGRwyLy0XyPaS4i4hSRF0TkR/key2xExCciT4jIiyJyVESuzfeYphORjyX/jA+JyGMi4imAMT0sIgPJhjPWYzUi8lMReSX5+4oCHOPnk3/OB0TkSRHxFdL4pj33pyJiRKQwezdSZIE+rWH1W4BNwB0isim/o7pAFPhTY8wm4Brg3gIb33QfBY7mexDz+ALwY2PMZcBWCmisItIM/A9guzFmM4ljpQvhyOhHgJtTHvsE8DNjzHrgZ8nP8+kRZo7xp8BmY8wW4GXgk7ke1DSPMHN8iMhq4E3AyVwPaDGKKtCZ1rDaGDMJWA2rC4Ix5rQxZn/y41ESIdSc31HNJCItwFuBr+Z7LLMRES/wmyTO2ccYM2mMCeR1UDO5gLJkh65y4FSex4Mx5pck+hFMdxvwaPLjR4F35HJMqWYbozHmJ8aYaPLT50l0RcuLOf4fAvwj8GdAQd90LLZAn61hdcEFJoCIrAWuANrzPJTZ/F8SfzlndrkuDK3AIPAvybLQV0WkIt+Dshhj+oD/TWK2dhoYMcb8JL+jmlOjMeZ08uN+oDGfg0nDB4B/z/cgphOR24A+Y0xnvseykGIL9KIgIpXAd4E/NsYE8z2e6UTkbcCAMWZfvscyDxdwJfBlY8wVwDj5LxVMSdahbyPxjacJqBCR9+R3VAtLtoUs2BmmiHyKRNnym/kei0VEyoH/Bdy30GsLQbEFejoNq/NKRNwkwvybxpjv5Xs8s7geuFVEjpMoWb1BRL6R3yHN0Av0GmOsn26eIBHwheImoNsYM2iMiQDfA67L85jm4heRVQDJ3wfyPJ5ZicidwNuAPyiwfsQXk/jG3Zn8N9MC7BeRlXkd1RyKLdDTaVidNyIiJOq+R40x/5Dv8czGGPNJY0yLMWYtif9/PzfGFNTs0hjTD/SIyKXJh24EjuRxSKlOAteISHnyz/xGCuimbYrpDdzfB/wgj2OZlYjcTKIEeKsxZiLf45nOGHPQGNNgjFmb/DfTC1yZ/DtacIoq0JM3TqyG1UeB7xhjDud3VBe4HngviVlvR/LXLfkeVJH6CPBNETkAbAP+Or/DOS/5k8MTwH7gIIl/R3nfTSgijwG/Bi4VkV4RuQv4W+CNIvIKiZ8s/rYAx/j/gCrgp8l/M18psPEVDd0pqpRSNlFUM3SllFJz00BXSimb0EBXSimb0EBXSimb0EBXSimb0EBXSimb0EBXSimb0EBXSimb+P8BfV7FjBckCGwAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output example of first prediction:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for idx, prediction in enumerate(predictions):\n",
    "    pred = 2 * (prediction - 0.5)\n",
    "\n",
    "    if pred == 0:\n",
    "        color = 'grey'\n",
    "        text = 'Neutral'\n",
    "    elif pred > 0:\n",
    "        color = 'tab:red'\n",
    "        text = 'Fight'\n",
    "    else:\n",
    "        color = 'tab:green'\n",
    "        text = 'Non-Fight'\n",
    "    \n",
    "    plt.bar([0.3], pred, width=0.2, color=color, alpha=abs(pred[0]), edgecolor=color)\n",
    "    sign = .7 if pred > 0 else -1.3\n",
    "    plt.text(0.255, pred[0] + sign*.1, f'{abs(pred[0]):.2%}', color=color, fontdict={'fontsize': 12})\n",
    "    plt.plot([.0,.6], [0,0], color='grey')\n",
    "\n",
    "    plt.text(.665 if pred > 0 else .625, -0.03, f'{text}', color=color, fontdict={'fontsize': 15})\n",
    "    \n",
    "    plt.ylim(-1, 1)\n",
    "    plt.xlim(0, .8)\n",
    "    plt.axis('off')\n",
    "    plt.savefig(f'predictions/{VIDEO_PATH}-{idx}.png')\n",
    "    if idx == 0:\n",
    "        print('Output example of first prediction:')\n",
    "        plt.show()\n",
    "    plt.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('tfg-info-env')",
   "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.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "87fec3b9a0b1ed2d3126393c43def24f1a4854a00a756618c381a338b4c17bda"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}