GradiantVis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import keras\n",
    "from keras.models import Model, load_model\n",
    "from keras import backend as K\n",
    "import numpy as np\n",
    "import params\n",
    "import random\n",
    "from keras.optimizers import Adam, RMSprop\n",
    "\n",
    "import midi_utils\n",
    "import plot_utils\n",
    "import models\n",
    "import params\n",
    "\n",
    "import os\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "# User constants\n",
    "dir_name = 'results/history/'\n",
    "sub_dir_name = 'basic'\n",
    "num_measures = 16\n",
    "use_pca = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0608 23:25:06.865839 31156 deprecation_wrapper.py:119] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:517: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "W0608 23:25:06.904905 31156 deprecation_wrapper.py:119] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keras version: 2.2.4\n",
      "Loading encoder...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0608 23:25:07.065491 31156 deprecation_wrapper.py:119] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:131: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "W0608 23:25:07.066457 31156 deprecation_wrapper.py:119] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:133: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n",
      "\n",
      "W0608 23:25:07.201126 31156 deprecation.py:506] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "W0608 23:25:07.821541 31156 deprecation_wrapper.py:119] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:174: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n",
      "\n",
      "W0608 23:25:12.050011 31156 deprecation_wrapper.py:119] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\keras\\optimizers.py:790: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n",
      "W0608 23:25:12.060956 31156 deprecation.py:323] From C:\\ProgramData\\Anaconda2\\envs\\tensor3\\lib\\site-packages\\tensorflow\\python\\ops\\nn_impl.py:180: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading gaussian/pca statistics...\n"
     ]
    }
   ],
   "source": [
    "print(\"Keras version: \" + keras.__version__)\n",
    "\n",
    "K.set_image_data_format('channels_first')\n",
    "\n",
    "print(\"Loading encoder...\")\n",
    "# priority name.h5 in sub, model.h5 in sub, name.h5 in dir, model.h5 in dir\n",
    "if os.path.isfile(dir_name + sub_dir_name + '/' + sub_dir_name + '.h5'):\n",
    "    model = load_model(dir_name + sub_dir_name + '/' + sub_dir_name + '.h5')\n",
    "\n",
    "elif os.path.isfile(dir_name + sub_dir_name + '/' + 'model.h5'):\n",
    "    model = load_model(dir_name + sub_dir_name + '/' + 'model.h5')\n",
    "\n",
    "elif os.path.isfile(dir_name + sub_dir_name + '.h5'):\n",
    "    model = load_model(dir_name + sub_dir_name + '.h5')\n",
    "\n",
    "else:\n",
    "    model = load_model(dir_name + 'model.h5')\n",
    "\n",
    "\n",
    "encoder = Model(inputs=model.input,\n",
    "                    outputs=model.get_layer('encoder').output)\n",
    "encoderFunc = K.function([model.input, K.learning_phase()], \n",
    "                    [model.get_layer('encoder').output])\n",
    "decoder = K.function([model.get_layer('decoder').input, K.learning_phase()],\n",
    "                         [model.layers[-1].output])\n",
    "# decoder = Model(inputs=model.get_layer('decoder').input,\n",
    "#                     outputs=model.layers[-1].output)\n",
    "\n",
    "print(\"Loading gaussian/pca statistics...\")\n",
    "latent_means = np.load(dir_name + sub_dir_name + '/latent_means.npy')\n",
    "latent_stds = np.load(dir_name + sub_dir_name + '/latent_stds.npy')\n",
    "latent_pca_values = np.load(\n",
    "    dir_name + sub_dir_name + '/latent_pca_values.npy')\n",
    "latent_pca_vectors = np.load(\n",
    "    dir_name + sub_dir_name + '/latent_pca_vectors.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 16, 96, 96)        0         \n",
      "_________________________________________________________________\n",
      "reshape_1 (Reshape)          (None, 16, 9216)          0         \n",
      "_________________________________________________________________\n",
      "time_distributed_1 (TimeDist (None, 16, 2000)          18434000  \n",
      "_________________________________________________________________\n",
      "time_distributed_2 (TimeDist (None, 16, 200)           400200    \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 3200)              0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 1600)              5121600   \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 40)                64040     \n",
      "_________________________________________________________________\n",
      "encoder (BatchNormalization) (None, 40)                160       \n",
      "=================================================================\n",
      "Total params: 24,020,000\n",
      "Trainable params: 24,019,920\n",
      "Non-trainable params: 80\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# model.summary()\n",
    "encoder.summary()\n",
    "\n",
    "encoder.compile(optimizer=RMSprop(lr=0.01), loss='binary_crossentropy')\n",
    "# decoder.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Data...\n",
      "Loaded 8980 samples from 172 songs.\n",
      "8980\n",
      "Preparing song samples, padding songs...\n",
      "saving sample\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "random.seed(42)\n",
    "\n",
    "# network params\n",
    "DROPOUT_RATE = 0.1\n",
    "BATCHNORM_MOMENTUM = 0.9  # weighted normalization with the past\n",
    "USE_EMBEDDING = False\n",
    "USE_VAE = False\n",
    "VAE_B1 = 0.02\n",
    "VAE_B2 = 0.1\n",
    "\n",
    "BATCH_SIZE = 350\n",
    "MAX_WINDOWS = 16  # the maximal number of measures a song can have\n",
    "LATENT_SPACE_SIZE = params.num_params\n",
    "NUM_OFFSETS = 16 if USE_EMBEDDING else 1\n",
    "\n",
    "K.set_image_data_format('channels_first')\n",
    "\n",
    "samples_path='data/interim/samples.npy'\n",
    "lengths_path='data/interim/lengths.npy'\n",
    "\n",
    "print(\"Loading Data...\")\n",
    "if not os.path.exists(samples_path) or not os.path.exists(lengths_path):\n",
    "    print('No input data found, run preprocess_songs.py first.')\n",
    "    assert(False)\n",
    "\n",
    "y_samples = np.load(samples_path)\n",
    "y_lengths = np.load(lengths_path)\n",
    "\n",
    "samples_qty = y_samples.shape[0]\n",
    "songs_qty = y_lengths.shape[0]\n",
    "\n",
    "print(\"Loaded \" + str(samples_qty) + \" samples from \" + str(songs_qty) + \" songs.\")\n",
    "print(np.sum(y_lengths))\n",
    "assert (np.sum(y_lengths) == samples_qty)\n",
    "\n",
    "print(\"Preparing song samples, padding songs...\")\n",
    "x_shape = (songs_qty * NUM_OFFSETS, 1)  # for embedding\n",
    "x_orig = np.expand_dims(np.arange(x_shape[0]), axis=-1)\n",
    "\n",
    "y_shape = (songs_qty * NUM_OFFSETS, MAX_WINDOWS) + y_samples.shape[1:]  # (songs_qty, max number of windows, window pitch qty, window beats per measure)\n",
    "y_orig = np.zeros(y_shape, dtype=np.float32)  # prepare dataset array\n",
    "\n",
    "# fill in measure of songs into input windows for network\n",
    "song_start_ix = 0\n",
    "song_end_ix = y_lengths[0]\n",
    "for song_ix in range(songs_qty):\n",
    "    for offset in range(NUM_OFFSETS):\n",
    "        ix = song_ix * NUM_OFFSETS + offset  # calculate the index of the song with its offset\n",
    "        song_end_ix = song_start_ix + y_lengths[song_ix]  # get song end ix\n",
    "        for window_ix in range(MAX_WINDOWS):  # get a maximum number of measures from a song\n",
    "            song_measure_ix = (window_ix + offset) % y_lengths[song_ix]  # chosen measure of song to be placed in window (modulo song length)\n",
    "            y_orig[ix, window_ix] = y_samples[song_start_ix + song_measure_ix]  # move measure into window\n",
    "    song_start_ix = song_end_ix  # new song start index is previous song end index\n",
    "assert (song_end_ix == samples_qty)\n",
    "x_train = np.copy(x_orig)\n",
    "y_train = np.copy(y_orig)\n",
    "\n",
    "test_ix = 0\n",
    "y_test_song = np.copy(y_train[test_ix: test_ix + 1])\n",
    "x_test_song = np.copy(x_train[test_ix: test_ix + 1])\n",
    "print(\"saving sample\")\n",
    "midi_utils.samples_to_midi(y_test_song[0], 'data/interim/gt.mid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(172, 16, 96, 96)\n"
     ]
    }
   ],
   "source": [
    "print(y_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(172, 16, 96, 96)\n"
     ]
    }
   ],
   "source": [
    "offset = 0\n",
    "epochs_qty = 1\n",
    "\n",
    "for epoch in range(epochs_qty):\n",
    "    if USE_EMBEDDING:\n",
    "        history = 0\n",
    "#         history = model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=1)\n",
    "    else:\n",
    "        # produce songs from its samples with a different starting point of the song each time\n",
    "        song_start_ix = 0\n",
    "        for song_ix in range(songs_qty):\n",
    "            song_end_ix = song_start_ix + y_lengths[song_ix]\n",
    "            for window_ix in range(MAX_WINDOWS):\n",
    "                song_measure_ix = (window_ix + offset) % y_lengths[song_ix]\n",
    "                y_train[song_ix, window_ix] = y_samples[song_start_ix + song_measure_ix]\n",
    "                #if params.encode_volume:\n",
    "                    #y_train[song_ix, window_ix] /= 100.0\n",
    "            song_start_ix = song_end_ix\n",
    "        assert (song_end_ix == samples_qty)\n",
    "        offset += 1\n",
    "        print(y_train.shape)\n",
    "\n",
    "#         history = model.fit(y_train, y_train, batch_size=BATCH_SIZE, epochs=1)  # train model on reconstruction loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flattenWindow(song):\n",
    "    flat = np.zeros((96 * 2, 96 * 8))\n",
    "    for i in range(2):\n",
    "        for j in range(8):\n",
    "            wix = j + i * 8\n",
    "            flat[i*96:i*96+96, j*96:j*96+96] = song[0][wix]\n",
    "    return flat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 16, 96, 96)\n",
      "(192, 768)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAB2CAYAAAAz69PvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAApBElEQVR4nO2da5Aj13Xf/+fexnuAGcx7dgbz2pmdfc8ud7nc4UOkKMt6paS4XFGRKdssxzLzQa6KnA8pslSVKB9USVxJKp/iChMpUSoxFUWJLZUSW5GYKIltORIlkRIpacWV+Fpyn7PPeQLoPvnQ3ZgG0AAaj35gdH9VU3jMbfQfF90XjXPPPX9iZigUCoVifyHCFqBQKBSK3qMGd4VCodiHqMFdoVAo9iFqcFcoFIp9iBrcFQqFYh+iBneFQqHYh/g2uBPRB4noAhFdJKJn/NqPQqFQKOohP/LciUgC+BmA9wO4BOC7AJ5k5h/3fGcKhUKhqMOvK/dzAC4y8y+YuQjgiwA+5tO+FAqFQlGD5tPrTgN42/H4EoAHnA2I6GkATwOAhDyTRq7+VdIp0M4uOJ0ANrYb7oyEACfjgKCm7XxjIAVsbgOZVHOdmgZoEqyJ0HTS5g44nTT1NoAScQAAa7LSrtLHWzvB6NwpArEYWDb+TCmVBAwDEAK8beqimAZICd7ZBWnSfI3t3msmInA6CSrpAAAuFhs3zqRAZavdrtmOEnGAGVws9VxblU6rDwAApTK4XG7ceCAFKhuAroNLZju3PvZFZ3zvmKOdXbBhWMdcAtjaBogA+7gdSAEGg3aKYMPwTZOrzmQCKOvgZKz1OTyQAhimfrexYaD5eOGFe7h1g5nH3P7n1+BOLs9VxX+Y+TkAzwFAjob5AXpf/Rb2+95s8IrOV7bbNmvnF5uO22b7162/3Rbt/MLWudVi/0XHrd3O7uMgdNs6deu20T6dY43dpmz9Efb62y/NWy7799quWPPYL+w+qN2/G5uO+3Y7tz72g1LNLaH+mLOPWzedQbFr3bY61+02zvu17b28Rgu+yV9+s9H//ArLXAJQcDyeAfCuT/vqb4SEOH44bBWKENEmJ6BNHwh8v+L4YUDIwPfbLuLU0bAl9BRtYQ4yn/d9P34N7t8FsExEC0QUB/AEgK92+mJyZLhnwvykow/M0EFXrkPmXMJSfkAEOTTY9mZBHIxOSNMgstmOtw9Kr0gmIZLJtrahWBwik6k81m/dhrF+s9fSqhCZDCgWr35uYwvgYMMarZBDg2YIxgG9eTkkNY3p5vgyrt2AsbHZumGX+DK4M3MZwO8B+DqAnwD4EjO/2vHrFSZ7Jc0/iMCFiY425Y1NYGq8x4LcIS3W/r6EBE939t46RaTTEGMjHW/Ps8EcM2JoECI/1N42A5mq98a7uzB2/J3LEOOjEJlU1XPGQBqgiC11mRqvxN9t9Fu3QhLTGC5M1H0JecXY3ASXmszR9AjfPllm/u/MfIiZDzLzZ7t5rdJQEnT6WHBXtx1SHkyBH1ytu0JqhbGzg9LYQCA/kUkK6NkkjEdPe9/I0IE33wGdPe6fsFriMRgDbeq0IUI5197VdMekkuBsBvzgqudN9Fu3wDENWmEGAKDNz0JbnPdJoImRSYGG86Azx/Z0DCZBIozJn8bo2SRE4QDkyhJEOg2cOxG2JFfKuSTkkWXP4TT7OO7oeO4QX/Lc26XhhKpCoVAoGvJN/vL3mPms2/8i9pusHpFMQh46GLaMlshcDtrCXFevoU36H/qQY2PQpqIf5tIKM93NtQhpvlef+1QuLXQ1NxAUcmUJlEhUPzcx3nFowReIII8su/+CJYIcc834CxzSNFOnB8Ls48gP7pRKoTjd/gRg0FB2AKXJoa5eg0e6294T+RyMTvYT8AGqjw6Ccp0PmiQIGMqCh/09dkqTg6B0qnXDkNmdGayLZWMoF62YOwlszw6CpNvgLoB8NMKypGnYKdRP/LoyFJ5mFZaJEHJ5EbS9i/Kld8KWUo2Q4PPHQX/5cthK9gVyYhwYHoT+k9dC1cFrqxDffbX5wiZFpOnrsIycGMfGx897astr5mSmc9IoKOTSAnY/cr+3xudPQg4NQh49VPW0fvF1lGc6zxDxAp09DuPhU63bWf2oTR+ANjtdGdh5zfvEYTeUHz8DcbJ1/r/M5SCPrUAuL9b9bJf5POTRQ75q3vq1B6DNFVq206YPQFuYg1g9Ar63Af0nr4ESCdBp81glTfN1wvruk+frwlyipNe1s/uR7j8ReA48aRpu/+aaa2pp7XktTh6GyGQCOx6diGwWd37jvKcrd7r/hLky/fzJAJTV7DvyV+5CQqSSMDZb54VSIgHe3QXF4oGkGlXtW9NA8TiMra3WbRMJcLEIkrLuqsl+D35BMbNMg5d9UCwO1s0BgKSEHB2GfvOWr/psRDIJ1o3WnyORmd7JhqnVeTwTmT/xpfRNs0inYezsmhlFTRtKM1REAlwqmnnSug5je6fyHv08bkU2C2Njo6p/KBaHPDCB8pt7lUJI08C6DorHA/mcXXXeu+f6P21hDuU3L5lrQ2JxcLkUjk4iiIGBhjqrmtpjkk/ndbMrd7/KD/QOQ/c0sAOodF7QAzsAcLlF3Q5nW1unS3u/D9R2+qaqrZSApgV2InnO+2Zu/J6YzT72MexQ+TIXsvkAb+jV64WkML+QHNrtL1I/cBuIuFQExzRzQLf6qHIbwsAOuOuswAwRj8HY0Sv9FopOZk8DO+A418P4ogx8j4q+hEtFlN++FLaMSEKaBpxtb4m8fmMd+u071a9xLvhwon7xdRgPBLh+oQvKb7wF/b6VaGX4RJi+GNy9xIhDh6ithSxhIZLJYBcjdYgcGYY8thK2jJZocwXImQPAd37U3naL89Bmpn1SVY88eghy1H0+h/7ipcB0tILOHGtazoH+8uXq0FtI8Npq5L9k+mJwj62bYRmRyUQ6R1uzdMqR4Y5ytOXyYq8l1cG6AXlzA4A5yeesceKFIDQCMEv23jX7U5ufNa9s20AuLUCk074X5OLNLWBn1ywGtbTQ1na8vVfulQ2GXN/wQyIAgO5uVsoN136GQX2mXpC3NsG6Yea1t9GfQaNZnxXF4tDmZ0NW4070Y+4AyK55rOvgsn9xya5gBtm1zkudxXhpJ4C5AjYAqy43F0tAm3HeQDQC5me9Y8Upd9vfJ+2WwIbhe710FEtg3QBJCRJtXCsVS9VzLmyAtv2Ly/LODlAy+6L2MwzsM/XC9o55jDJHS1cNtLVj/oJgo6PjMwiiny2jUCgUClf6Os8dqC62YzwSXOGdtiCqmhtoVyc/dCqQvGKRTFaKMVEsHkqesBfk6AjEycMwHjkNmctV8sFboU1OeF4a3gu0+VnIQwfBa6vQpg+0VSqDEolK/rPfBaXksZXKOgC5slQJVwVZyMoLdP8Js2AY0FGxQHlsxVwk5jP80KlKzJ3XVtsOGwZBV1fuRPQGgHswvV7KzHyWiIYB/CcA8wDeAPBxZm5as/OX+cpdHluB/uqFsGV4RpuaBBeL0H2uP95PkKZBLC+0teJUm5wAl8vQb6ybi4akQPnKVR9V1iNXlmD8/I19t0JVLi3AePvd0NI5g8TvK/f3MvMpxw6eAfACMy8DeMF63BVydKT5NyNR5du+3QnCXiLHxppefZOmVTIBKjqDjtcRtbyyoVjcWuwk6zIXjI1NIIirFKvwV7OiXCKZNBcHxeJ1RbHsY8Lvol4Ui0Pk803j5SKdNhdUJRKV49jY3AJv75hXpmzAuOffZCpgFeCrNWm5eady3gB7x6StNwxENtvyHLY/U7d2IpkEbW5D1B4PPUbm8/XHXK0Wuz9DKiznR1jmYwC+YN3/AoC/3u0Lbjx8EKJJ9olIJEAL5hJwPjzf7e46gwh3HluESDVO4xKDOdDMlDlwLpkz7MZQsF9GFI/jzqOLTb8s5eQ45OgwRCYNmpup+p+xsQFjxv/qfDI3gLuPLoJXGlfapNlpyIEM5EgecrL6C4u0GLA023T7nugcH8XGgwswhgYaN1qaBWkxyOkpCGuANe7dAxdLKJ9YBIaHPC/U6xRaKKC0Wp0Vo1+/DuPQXqYHH543v4QWChCpcIqhGUfmgeXmn5n9mfKh+bqLKZqZMi8+ZvzNqts5swg5PdW4AZGpD/D9GGwoocuwzOsAbsG0sv1XzPwcEd1m5iFHm1vMXOdJRURPA3gaAJJIn3mYPtyxjr5GSPDaiUjlGiuCg9dWIb7/01BDCMajpyH+9w9C27+ic/wMyzzEzPcB+BCATxLRe7xuyMzPMfNZZj4bQ+ufUPLQwVBDLl4Rxw+3N7li6KEM7N2YDlMsXlf0zC/6why5C5Nz7dXXIQoHAnmfIp12nfCNvXM7Ui5ncnSk4lLV0fZHlluGTHqBVphpuDAsCnQVPGXmd63ba0T0xwDOAbhKRFPMfJmIpgBc61akHBkGbW7DiPjEj8znQRtbKBvhp5c2hAhyMAe6u4VOrZG5XAIuXemprFpI00CpFEQXOoNAJJOAlBAbnek0trZAVxm07u88hshkACFAm9t1/+OrN6oWVIWJHBoEdGNvjUObiEwGuH4T3OFaE6/IfN7U6Pc6ii7o+MqdiDJElLXvA/hVAK8A+CqAp6xmTwH4SrciuTAJTifdi/hHBcsgmzOpyPlSOrENso1sFzFVZuh37/ZOlAu2QXZXOgNADA1CDOfBmc50crkM4949302gxfgoRC4LTtfPCRn37kUnY2ZqHJROgZKdXXmLsRFAN1pX6ewSLkyA0kkgHvN1P93QTVhmAsCfE9HLAL4D4L8x858B+McA3k9ErwF4v/W4K9ZXB7G11CJjJgJcO5/H9kw2Wu42NZAUuPqeUeyOpVs3dn0BCmatQTyGq49PoZSP9uCOVBI33ltAeTAgQ+4O0YcGcOvhWRi5aPfn7lQOdx8ouH4JeYEzKWBkyPf6SfeWB7FxciqQ8E+nqBWqCoVC0af0/QpVbXLCjLtH/MpdToxHz3S4li6No4Mw8QbM1Zsyn++JTj81i0zGdIPqYlVkL16jFTKfh8hmXQvayXzeTM+NAHJ0xNTZxQSvHB3xfbW3nBiHHBqsWicQNfpicOdh0yw50oM7ETA8CAxGPSwjgcGBjo2j/TactqF4HJQb6Ng0nB1myn5qpnQalEmbn3unr5FKmq/ho5kyDWTMWLaL6TgNZkFRiR0P5cz1FZkuBs2hHCjm81gxPAgaGFBhmVaosIyiEcYjpyH+r8rB9pP91Mfy6CFg/Tb0q10n6fUFfR+W4bXVpsbOIp02jYfDLIJFBJw7gfL7zjTMeZajI5ArS65muUEZElMiAXHqaFNjZ21+FtrCXJ3RuBwbC6z2t8znIY8sY6OQaFgbXx49ZJpl1Jp6EO31sc/GxFphBtrifENjZ8AsgKUtzEFbqF+paBul+33sypUlaHMFV2Pn2Pqm6el6/iTkoYN1RuNBIk4dhTY/i42Pn2/YhtdWKwbZTrSZadDWDnhj05O5elecOwG5soTdj9zv/n8hTXPsEIzGbfriyp0SCcDgpsbO7Rg/+wUlEiCixsbOTQyb/TbGrtpXLA6Kx2Bs77injNWYOe9tSK6m3v6INPdFqVSdsXOliaaBDTY11fS338bEFay+olSqoa8mxeKwDVTr+i4AE29gr69EJl2n02mKDV2vNxoPENuUXaSSDUsy2OMBl0vVOu1BlA2QFvPVS5kSCcDqs4qPrlsb+Ouf2t8G2fDWOWGYYtdp2N1F01OiiWEz7+5WGRX7CZeKzfur1sy5siEHlw9t72t7u+FAUzFzrv2CIgIXAzJQtvqKmxgmN+1r5zHRymS7C+y+cjXKDtkU24ndV81q7TTU6eg7P83GnRqanQ9h92dfhGV+WegXo+Ig6aRPtIU53+31ek1YBtn7EZHJQJyMvv+u36jBPSLw2iro2+2ZLAeJyGQ8G2b0knbr7siJcXBMQ/nSO/4I8gGtMANZmAb+6odhS9kXGJubMF76cdgyQqcvBne5vAitMNPUFT0KyKUFc9KszQkUSiQQu3Lb9yXTgHmFqM3Ptj0xyuUy5G1/a447EZmM6WzUpk796jXQnXvmBCH8N3+WI8OQE+Ouk6VuUCxeN5HN29vgDfe4ba/QpiYbFuSKkkG2NlcwEw86yPmX+Xxghbzk0oK5/iZCBddq6YuYO+0UwcWi6YoeYWi3BBgG3APWTTC4YlodCLtFULt9GbRGXQcXS+2ZTlvwbrESC/XdZLlUNvvG6xoMN0PlYgnwuR4Rl0pAuVyZi3ASKSPqoqmzowldXd8796yJbr/miGinCC6VfI/td0NfZMsoFApFO8iJcSCbgX7x9bCl+Epf57lrU5O4/VtrlcdRNciWK0vY/PUHKo+japDNa6soP34GxiOnvRtkCwl+MNg1BLsfur8S42/HIBtAxaxcjgz7nu9874nz0BbnAcCTQTadOVafnz1XqLyGX9z87bU6g2x+MFrGzqRpWP/dta4Msm3KSweg/+KtXsqrIHM5rH9ibX8bZPeKllfuRKHl3bZFhzopkYAoHAjuKqMf+rMLjdrUJLisQ79+vceiXOhApxwyl64HOunrolMeWYZ+4ReBzPV4pgfHpkgmQTNT/p5PETmHurpyJ6LPE9E1InrF8dwwEX2DiF6zbvOO/z1LRBeJ6AIRfaAb4bZRrxho4k9p7jQQM+RGOI2FK/ct82YAFWNkp0F2FboO3LpT9Vq+6Mxmzb5q4Y9ZMciuepICK5IkMhmARMMJdLc+tjHXCuhgnz1J7f4gLWZ+ObuZNdtGzjWG07yzCy6VginWZZmci0Si/pfhjdtV80MikzEHxhCuQu1jTqRSLQvviWy2qYk3xePAHX8m/+1jzsu5IDKZuuMiyD72Epb5dwA+WPPcMwBeYOZlAC9Yj0FERwE8AeCYtc2/JKLOYw2LsxCJREuDWdsgOywjWj40bw4qh+eB5TlzIC8cgMyZX0rywKRp6mAZZNdtXy5DX79pLr7x0eCbV+bMA39xtmk72yDbiUilQPOdW595xuoDmRsAFRrkqi+bGUm2QXaVzqFBUDbTcNVgz2TGTZNzOT4KOTXhaupcOR4tg2wbY2cHlExAjtRZC/ccux+pcABysDrEoV+/XnX1yYfnQTN7Jt5BIsdHISfGgMVZs2+bwCtzoPmZxhcphammi8q6gWamIAdzpvl1sy8h2yB7uTp7rtLHg/5n2XgKyxDRPICvMfNx6/EFAI85rPS+xcwrRPQsADDzP7LafR3AZ5j5281eX02oKhQKRfv4MaE6wcyXAcC6tZNSpwG87Wh3yXquDiJ6moheJKIXS/BnmW5UzZXF6hHHg87Nlf2ENK2+IBei16cim3XN067q4wggx8agzVSfCkEajXeKXF4MLdyp6I5eZ8u4/U5x/WnAzM8x81lmPhtD85rIjaoCthTz5mVztj2kqmyNoLcc5tKGDrp0OTwxDWBdB96pN8GmN6Ollbe3wVfqJ06r+thviExj5yYYd+/CuFntkxqE0biNyGQ6ivHzleugRDwwAxo5NBhtsxsLe5FclOl0cL9qhWNg3drFky8BcC6/mwHwbufyTLgw2dF2+q1bwNQ4RFSMCCxqzZD123dCUtIEZlddfhs5t4ttMF1LkDpJSmC6+THKu7v18wABGI3biPFRiA5MvI1794DxkeDM6afGW8bcowAXJiL/JdTp4P5VAE9Z958C8BXH808QUYKIFgAswzTP7orSULLjnFcjlwKkhP7Yfd3KaI5lHM0Prnq6QpL5fCghDpFMAudOwHjUWx6+VpipC3uIZNL3OulydATi5OGKTuOR001PJnn0UJ2dnhwZ9j08oy3MQSzOeTbIprPH6/Pc52d9z3M3MinQcL6uRr8nrt4AHVvuvSgX9GwSonDA9D1oE22uALm04IOqesq5JOSR5UgXqGs5oUpEzwN4DMAogKsA/gGAPwHwJQCzAN4C8DeY+abV/tMA/haAMoBPMfOfthKhJlQVCoWifbqaUGXmJ5l5ipljzDzDzJ9j5nVmfh8zL1u3Nx3tP8vMB5l5xcvA3gqRTLZc9RcFZC7nOQ88KJNpNzwbjRO5OvIEpV2OjTW8UneakFMs7jonE5ROr/txXYdhmZUHgVxZ6srvU2Qy/k+sEkEeWY7cHFktpGmmzogT+fIDlEqhON1l3m0AsTHKpD2fPEGZTLtBuaynmCZJCQzVn8yBac/nGhuND+39j2IaKFu/yM1pkO0nlf5ocYxRKglRY/pMglz72A92Zwa7imW76e85JLA9OxhcfL9DSNOwU4j+xG9/lB/oEn7olFkrPUrLrBX7BtI0GPcfA3375bCl+EpUjbTF6hHQW1ciN9kfBH1dOExOjDc1y3XCa+ZkpnPSSKwegfzBz3wf2OXSQmOz3Fp8noxsRjOj8ap2Nf1oE5QJefnxMw2LftHZ45XQkszlmhtk+8zWrz0AMV+AKDU/vrTpA3U13ymRCMwA5e6T5z2lFMvlRcixMVdj59jVu77WSydNa2o07sQ2yOa1VVC5gzLbXSCyWVejcTfo/hPmsRrCOR/9K3chm5rlOqmYIsfiFS9G530/IU1rapZb1TZAM+y6fbdhJO7Wd0FpF8lkQ6PxKl1ErmbIgelMp80a6bVm4nUN3euLB3V8imy2odF4lR6HWXadibv1Pz8LZolstqHReJWWWBxcLlVMveXUJMrvXA7m17lV78qTTp+N2vvbINvQPQ3sgMO01nGyVAZ5n82nuVz2/PqVD9lHQ+SG+25jIOFSce/qxDqhg9Ju7LgYg9glVp3vgTlcnfaXucskYNUxZ5uO1+hx0+6LTo+1VpqZZbNt4s0+9qdXnaUaA3QZYBCC2btOe0wK4WIu8mGZXqGfj5b5tBwahDga/Rn3huGE+4Jf3i+XF6E1sF+Thw5Cjldnnsh8HvJI+/nS7UKaBpytX7PgZu5Nq4fr89xnpqHNNy/mFgWibOJdfuMtNadWQ/TDMgCMh09B/PlLXe1DLi2AtndRfqfrBbMKRd8hjx4Crq1Dv7EetpSm0JljoFd/7v7LLULw2iror34Yek33vp5QBYDYuhmWEZkMtKnOShFASkCTvpps26vj5Miw53o4QZsT2wbZgHlV7ql+PJHrCko/tTsNsrX5WTO3eGK86SplN/Npv3U6DbJrV0c22q/IZuvz4xv0ca+gu5tgy7u10/7QpiZ9z3WXtzZNr2SitlebBmmQra2b9eIpFo/sr67ox9wB0Ma2eUfXweXOfnrR1o5psu3jNy3tlsw7Je+x/VDMia2TnIsl0yjEC8VS3VO+ancaZNtx63K5uSGxm/k0fNbpMMiuNfNuuF9dd5+fcenjXsE7O0Cp1FxXq9cotXG8dMr2jvk5Mrev02mQ7TO0tWNetTc45qJAX4RlFAqFQlFP34dlnEWuOjXIlsuLdfW0/aSVTpnPh15z3ItBtlaYqft5bBcfCwovBtnyyLJ74TCfDbKdOA2yG5lPh2WQLY+t1Blkt0MQGgEzL7wjg+zzJ7sqr9Au/NCpvewtZZDdmCCu3OWxFeivXvB1H4pgkCtL0F97PTrZEUJCLi9Av3ARAKAtzsO4cs13q7+gEJkMxNiImZGiiBR9f+UuR0eafzM6zJudV0UVg+JMBrR+20+JAKxiVx6LHvlphN0UIrPwlheE+wR0INqbFNWiuxsQyb2rNIrF66/aAjL0tguXkSPuynfuglw8BGyj9Coa9HGvEclkS0MRp9F7laF3sQTe3gnE0Ftksy2PL+d5Xfe/gMynZT7f8pdCpT9DcrJqObgT0eeJ6BoRveJ47jNE9A4RvWT9fdjxv2eJ6CIRXSCiD/RC5MbDByGaZJ/YBtkAqgymbYNiPjSP8tVrbpv2DiLceWwRItX6RKWYaa4cBhSP486ji55OAJFJg+ZqTLF9NvG2kbkB3H3UPauDd3ZBB/ZCMHIkDzlZ/YVFWiyQPpbjo9h4cAHG0F7xMn39Jnh+uu6LXk7Xm0/LgQxo1v9wIS0UUFptniXDh+fNFb8LhSrzaS4VQULU9bEfGEfmXc3GnTjP69o+Dsp8eufMIuR0vdn9nhDLIBsOo/SA8VLP/T0ANgD8e4dB9mcAbDDzP61pexTA8wDOATgA4JsADjE3X9IWRFhGf+w+yG9939d9KBQKRZB0W8/9/wC42aqdxccAfJGZd5n5dQAXYQ70XSMPHewqHJD4+bVAameL44c9/ywMc0K1HRcot7by2EogP3/d9i2OH64PfwnpOnkaSB+3YXIukklXl6EgXLlEOt2RN4LIZgNzOALMMKxWmGndMGS0wkxgefWd0E3M/feI6IdW2MZ2i50G8LajzSXruTqI6GkiepGIXiyhed0FOTIM2tzuqjaMsX4TRgB+lXTpcvNcbGfbIE2ca/fdhtG1a9t3rnh+n93gtm+65FIgytBBb7m0DaiPxYa3yVOjWAIu14cI/TYeF5kMICVoc7vtbSmZBK4Fs7JVDg0CugHeCaewnldkPm9q9HFtQrd0Orj/IYCDAE4BuAzgn1nPu9XAdI37MPNzzHyWmc/G0HxigguT4HSyqyL+xtZWIMV79Nt3PC9JDrP+dDv7dmvbzvvshob7dmsbkqE3CQJ7NZ82dFdTbL91ivFRiFwWnO5g8nYsH1zmz9Q4KJ0CJYNLa+wELkyA0knAZeI8KnQ0uDPzVWbWmdkA8K+xF3q5BMC5/nsGQNfFXNZXB7G11CJjJmyIcOPpNRQ/cLa9rAIhzZzZgBDJJG787TWUfuVMe9tls6Cze4Ww7Nr5fiFHR7D+ibU6Y3M60zz3WZucMOuoWHg1Au8UbWEOt/7m/Z4Nsm3k8mJV6MFvA3d9aAC3Hp41DePbQJw6Cly+7mtFVSe7UzncfaDQ2ZeQBd1/wveMrnvLg9g4ORVobn27eMpzJ6J5AF9zTKhOMfNl6/7vA3iAmZ8gomMA/gh7E6ovAFiOwoSqQqFQ7De6mlAloucBfBvAChFdIqLfAfAHRPQjIvohgPcC+H0AYOZXAXwJwI8B/BmAT7Ya2L2gTU54N3YOGad5cyvCNMpuZ9+1bYPU7dyXzOWa5oRX5e8HaD7dztoB0rSqSTiKxSHz+SZb9AaZz5sTox4L2oWFHB0xdXpdmVq7/dBgIFfTcmLcLNsdwFqKTvGSLfMkM08xc4yZZ5j5c8z8m8x8gplPMvNH7at4q/1nmfkgM68w85/2QiQPD5rGzn0wuGMw29jYuYagTJxd992G0XVt2yB1O/dN2QFQqkFYgcg0zrYfBmg+DRLm5+4FKUG5vbYUj4Fy9QbfvYYGMmYsOxfOghrPDOXM9RUdmnHTwABEEKGS4UHQwED/h2X8RoVlFAqFon36vvwAr602NXYW6TTE6pG6Ili8tgqxeiSYn05EwLkTZn3vIx4dlsIwzU0kIE4dhVaYqcslFum0a761W3ExOnPM3wnVfB7yyDLkylIllNC0yJmQpqlzLT73sVaYgbY4793Y2TpWa/HbeFyuLEGbKzQ3dj5/0nS0qglnyaHBqklqPxGnjkKbn8XGx883bMNrqxWD7FrkoYPB5J6fOwG5soTdj9zv/n/reHQzGg+Kvrhyp0TCrJndxNjZzfjZ3i4IA2J7f1wsgqT0lF0QllE2xeJ7Oeo1+eJeTbF9N3YmqqS+2qbMrfrLVafffWwZX1Mq5dlXMwzjcdI0sMEQmXRDnZRImLXma02wrc8iiIwZ+9gUqWRD7+TKeV0u1aXjBmHiXdFgGYk3ShO1QzZ+fq79bZANb53jNtBUDfQ+G2Q79xd1o+yGg7KQzfvRGsi4XPb/C5O5rh95d7dpX/HurnlVas95GLr/X56W8TVves8DrzLFJhGITrsvm30BNdTAbA6YRL4PmvZx1WhgB5qPB0GYeDs1NDvXw7hwc9IXYZleEDWD7ApCRsZ0WJxcaVjBTmQyECdXXE2fg6SZRgCQ42OQK4vgAD/vRgbZzdAW5qAtzIViNN4J/WLiDVgm5BHOYgmKvgjL9AJlkK1QdIbM58HTEzBe+WnYUloijywDN25Dv349bCmB0PcTqvZqvnbqXtcVOpIS5Xf9rd8hlxagLcx1NIGiLc57zo/vBtsg280kuZHBtBN7u07fp1ecBtm1eOmrilm5zwbktkG28ejptlN1nWblfuvUpiY7LshF+UHwhV/4oKoeba4AOTri3XPA3m5hzpwIvnknkIFdLi2Y6286zMcPgr6IudNO0TS31r2b31bMqu3HtqGtj9BuCTCMzkx6gyxAtFsEufUlGy11VEyL/dbrNMiuxcO+7c/fdwNyyyBbbrS/Hza4Yqbut04ulUyD8WIH+9ktBlIkDoD52ZbL7Z+rle0CMsjeKYJLpeD6pQN+acIyCoVCsd/o67CMNjWJ27+1VnncqUG238hDB6tMhz3rFBL8oL85zlW7O3UUMpeD8chpTwbZle0yGdCZY74X4rKxC5MZj5yuMsimM8eaTqjahcMarYnwA9I08NoqNn/9Ac9rHOTSghmKCWitw83fXuvYIDsoo3HSNKz/7prZN4cOejbIFqtHIPP5wMYGmcth/RNryiDbCy2v3Imgzc/CuHq949KjyiC7NZRIQBQOQL/4ethS+gshIVcWof/0YiBlkDuiyzRGOTYGkgLlK1d7KMqFANItu0UuL4LffhfGzk7YUvo/zx3M4Lv3OosXWgRhkN3vcKkM3Pbf0GTfwQZw43a0B6UutfHWFtht/qPXRLkPbW7dMU1XIk4krtyJ6DqATQA3wtbikVH0j1agv/T2k1ZA6fWTftIKhKN3jpldy59GYnAHACJ6sdHPi6jRT1qB/tLbT1oBpddP+kkrED29kZ9QVSgUCkX7qMFdoVAo9iFRGtyfC1tAG/STVqC/9PaTVkDp9ZN+0gpETG9kYu4KhUKh6B1RunJXKBQKRY9Qg7tCoVDsQ0If3Inog0R0gYguEtEzYesBACL6PBFdI6JXHM8NE9E3iOg16zbv+N+zlv4LRPSBgLUWiOh/EdFPiOhVIvo7UdVLREki+g4RvWxp/YdR1VqjWxLRD4joa1HXS0RvENGPiOglInoxynqJaIiIvkxEP7WO37UIa12x+tT+u0tEn4qqXgAAM4f2B0AC+DmARQBxAC8DOBqmJkvXewDcB+AVx3N/AOAZ6/4zAP6Jdf+opTsBYMF6PzJArVMA7rPuZwH8zNIUOb0ACMCAdT8G4P8BOB9FrTW6/y6APwLwtSgfC5aGNwCM1jwXSb0AvgDgE9b9OIChqGqt0S0BXAEwF2W9gXdMTSetAfi64/GzAJ4NU5NDyzyqB/cLAKas+1MALrhpBvB1AGsh6v4KgPdHXS+ANIDvA3ggyloBzAB4AcDjjsE9ynrdBvfI6QWQA/A6rKSOKGt10f6rAP4i6nrDDstMA3jb8fiS9VwUmWDmywBg3dpuApF5D0Q0D+A0zCviSOq1QhwvAbgG4BvMHFmtFv8CwN8D4CwUHmW9DOB/ENH3iOhp67ko6l0EcB3Av7VCXv+GiDIR1VrLEwCet+5HVm/Yg7ubnU6/5WZG4j0Q0QCA/wLgU8zcrPpXqHqZWWfmUzCviM8RUTOz01C1EtFfA3CNmb/ndROX54I+Fh5i5vsAfAjAJ4noPU3ahqlXgxn6/ENmPg2ztlSzObco9C2IKA7gowD+c6umLs8Fqjfswf0SAKev2wyAqJqcXiWiKQCwbq9Zz4f+HogoBnNg/4/M/F+tpyOrFwCY+TaAbwH4IKKr9SEAHyWiNwB8EcDjRPQfEF29YOZ3rdtrAP4YwDlEU+8lAJesX24A8GWYg30UtTr5EIDvM7Nd+ziyesMe3L8LYJmIFqxvxCcAfDVkTY34KoCnrPtPwYxt288/QUQJIloAsAzgO0GJIiIC8DkAP2Hmfx5lvUQ0RkRD1v0UgF8B8NMoagUAZn6WmWeYeR7msfk/mfk3oqqXiDJElLXvw4wNvxJFvcx8BcDbRLRiPfU+AD+OotYansReSMbWFU29YUxI1ExOfBhmhsfPAXw6bD2WpucBXAZQgvkN/DsARmBOrL1m3Q472n/a0n8BwIcC1vowzJ97PwTwkvX34SjqBXASwA8sra8A+PvW85HT6qL9MexNqEZSL8w49svW36v2+RRhvacAvGgdD38CIB9Vrdb+0wDWAQw6nousXlV+QKFQKPYhYYdlFAqFQuEDanBXKBSKfYga3BUKhWIfogZ3hUKh2IeowV2hUCj2IWpwVygUin2IGtwVCoViH/L/AZDlXJbMWnnzAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "song_ix = 0\n",
    "song = y_train[song_ix:song_ix+1]\n",
    "print(song.shape)\n",
    "flat = flattenWindow(song)\n",
    "print(flat.shape)\n",
    "\n",
    "# plt.figure()\n",
    "# matplotlib.rcParams['figure.figsize'] = [20, 20]\n",
    "# for i in range(16):\n",
    "#     plt.subplot(2, 8, i+1)\n",
    "#     plt.imshow(song[0][i])\n",
    "# plt.show()\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(flat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Const_1:0\", shape=(1, 16, 96, 96), dtype=float32)\n",
      "Tensor(\"model_1/encoder/cond/Merge:0\", shape=(?, 40), dtype=float32)\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "song = tf.convert_to_tensor(song)\n",
    "print(song)\n",
    "\n",
    "with tf.GradientTape() as tape:\n",
    "    tape.watch(song)\n",
    "    \n",
    "    latent_x = encoder(song)\n",
    "    \n",
    "    print(latent_x)\n",
    "\n",
    "    if use_pca:\n",
    "        current_params = np.dot(\n",
    "            latent_x - latent_means, latent_pca_vectors.T) / latent_pca_values\n",
    "    else:\n",
    "        current_params = (\n",
    "            latent_x - latent_means) / latent_stds\n",
    "\n",
    "#     print(current_params)\n",
    "    \n",
    "gradient = tape.gradient(latent_x, song)\n",
    "print(gradient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "composer",
   "language": "python",
   "name": "composer"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}