music_matcher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CS221 Final Project: Classical Music Classification by Musical Era\n",
    "\n",
    "This project aims to classify classical music by musical era (Baroque, Classical, Romantic, Modern) with composers as a proxy. Using audio processing techniques, such as Short-time Fourier Transform, we extracted features like spectrogram and chromagram of the audio data from two datasets, Free Music Archive and MAESTRO dataset. We used two ensemble classifiers,  AdaBoost and Random Forest, and found that although Adaboost performed marginally better than Random Forest, the latter made more generalizable predictions. Both models achieve an accuracy rate of 60\\% on the test data, which is significantly better than the baseline prediction of 45\\%. Our project reveals the complexity of the era classification task, and we expect more complex models trained on a larger data set to achieve higher success. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import IPython.display as ipd\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import ast\n",
    "import csv\n",
    "import librosa\n",
    "import soundfile as sf\n",
    "\n",
    "from pydub import AudioSegment\n",
    "from random import randint\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "\n",
    "METADATA_DIR = \"./fma_metadata/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datasets\n",
    "Our model was trained, developed, and tested on a combination of the following two datasets:\n",
    "\n",
    "1. *FMA (Free Music Archive)*: a large-scale dataset of audio files with rich metadata, containing over 100,000 tracks across 161 genres (Defferrard et al). From this dataset, we found 441 tracks that were categorized as \"classical\" and had a valid composer. \n",
    "\n",
    "2. *MAESTRO (MIDI and Audio Edited for Synchronous TRacks and Organization)*: a dataset with over 200 hours of labeled piano performances from 10 years of the International Piano-e-Competition, a piano competition that uses digital piano and records the music. This dataset contained 1282 songs that we could use in our model, making it the largest source of data for our project. Furthermore, we used the suggested 80-10-10 split, which eliminates overlap of pieces between training and test set. \n",
    "\n",
    "In total, our dataset consisted of 1723 songs, and we sampled the first 30 seconds of each song for feature extraction because practically a classifier should be able to make predictions with a limited exposure to the data.\n",
    "The songs were overwhelmingly from the Romantic period, with 789 Romantic songs in our dataset.\n",
    "In addition, we had 541 songs from the Baroque era, 280 from the Classical period, and 113 from the Modern era. The imbalance in the dataset may pose an over-fitting problem. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Extraction\n",
    "We used an audio processing library for Python called librosa to extract the following features using Short-time Fourier Transform from each audio file: chromagram, spectral centroid, spectral rolloff, root mean square value (RMS), and tonal centroid of a track. The chromagram is a distribution of the pitches in a track. The spectral centroid is a measure of the weighted mean of the frequencies over time in a sample of each data point. The spectral rolloff is the frequency below which 85\\% of the spectral energy lies. We expect this feature to be a strong factor because the most distinguishing factor across era is the distribution of spectral energy. The root mean square feature takes the root mean square value of the spectrogram, the distribution of frequency over time.  Lastly, the tonal centroid meaures harmonic properties of the pitches. We also expect to see high weight on this feature because another major distinction between the music from the earlier eras (Baroque and Classical) and the later eras, (Romantic and Modern), are the extent or lack of harmony. For each of the five features, we normalized and computed the mean and standard deviation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_dataset(metadata, composer_era_map):\n",
    "    \"\"\"Given a csv file with metadata from the MAESTRO database,\n",
    "    this method extracts the features from the audio files corresponding\n",
    "    to the data in the csv files and maps them to the correct era.\n",
    "    The method returns data that can be used by a machine learning algorithm.\n",
    "    \"\"\"\n",
    "    x = []\n",
    "    y = []\n",
    "    with open(metadata, \"r\") as csv_file:\n",
    "        reader = csv.reader(csv_file)\n",
    "        for row in reader:\n",
    "            composer = row[0]\n",
    "            if composer == \"canonical_composer\": continue\n",
    "\n",
    "            era = composer_era_map[composer]\n",
    "            audio_file = \"./maestro-v2.0.0/\" + row[5]\n",
    "            song = AudioSegment.from_wav(audio_file)\n",
    "            song_length = len(song)\n",
    "            if song_length > 30000:\n",
    "                short_length = song_length - 30000\n",
    "                rand_point = randint(0, short_length)\n",
    "                splice = song[rand_point: rand_point + 30000]\n",
    "            else:\n",
    "                splice = song\n",
    "            splice.export(audio_file[:-4] + \"_short.wav\", format=\"wav\")\n",
    "            features = get_features(audio_file[:-4] + \"_short.wav\")\n",
    "            y.append(era)\n",
    "            x.append(features)\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_features(audio_file_path):\n",
    "    \"\"\"Given the path of an audio file, this method extracts the features\n",
    "    using librosa and returns the features as an array of 10 float values.\n",
    "    \"\"\"\n",
    "    features = []\n",
    "    def feature_stats(name, values):\n",
    "        features.append(np.mean(values))\n",
    "        features.append(np.std(values))\n",
    "    \n",
    "    x, sr = librosa.load(audio_file_path, sr=None, mono=True)\n",
    "    stft = np.abs(librosa.stft(x, n_fft=2048, hop_length=512))\n",
    "    \n",
    "    f = librosa.feature.spectral_centroid(S=stft)[0]\n",
    "    feature_stats('spectral_centroid', f)\n",
    "    \n",
    "    f = librosa.feature.chroma_stft(S=stft**2, n_chroma=12)[0]\n",
    "    feature_stats('chroma_stft', f)\n",
    "    \n",
    "    f = librosa.feature.spectral_rolloff(S=stft)[0]\n",
    "    feature_stats('spectral_rolloff', f)\n",
    "    \n",
    "    f = librosa.feature.rmse(S=stft)[0]\n",
    "    feature_stats('rmse', f)\n",
    "    \n",
    "    \n",
    "    cqt = np.abs(librosa.cqt(x, sr=sr, hop_length=512, bins_per_octave=12, n_bins=7*12, tuning=None))\n",
    "    f = librosa.feature.chroma_cens(C=cqt, n_chroma=12, n_octaves=7)\n",
    "    f = librosa.feature.tonnetz(chroma=f)[0]\n",
    "    feature_stats('tonnetz', f)\n",
    "    \n",
    "    return features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "metadata = \"./maestro-v2.0.0/maestro-v2.0.0.csv\"\n",
    "composer_era_map = {\"Bach\":\"Baroque\", \"Haydn\":\"Classical\",\n",
    "                    \"Alkan\":\"Romantic\", \"Orff\":\"Modern\",\n",
    "                    \"Alban Berg\":\"Modern\", \"Alexander Scriabin\":\"Modern\",\n",
    "                    \"Anton Arensky\":\"Romantic\", \"Antonio Soler\": \"Classical\",\n",
    "                    \"Carl Maria von Weber\":\"Romantic\", \"Charles Gounod / Franz Liszt\":\"Romantic\",\n",
    "                    \"Claude Debussy\":\"Modern\", \"César Franck\":\"Romantic\", \"Domenico Scarlatti\":\"Baroque\",\n",
    "                    \"Edvard Grieg\":\"Romantic\", \"Felix Mendelssohn\":\"Romantic\",\n",
    "                    \"Felix Mendelssohn / Sergei Rachmaninoff\":\"Romantic\", \"Franz Liszt\":\"Romantic\",\n",
    "                    \"Franz Liszt / Camille Saint-Saëns\":\"Romantic\", \"Franz Liszt / Vladimir Horowitz\":\"Romantic\",\n",
    "                    \"Franz Schubert\":\"Romantic\", \"Franz Schubert / Franz Liszt\":\"Romantic\",\n",
    "                    \"Franz Schubert / Leopold Godowsky\":\"Romantic\", \"Fritz Kreisler / Sergei Rachmaninoff\":\"Romantic\",\n",
    "                    \"Frédéric Chopin\":\"Romantic\", \"George Enescu\":\"Modern\", \"George Frideric Handel\":\"Baroque\",\n",
    "                    \"Georges Bizet / Ferruccio Busoni\":\"Romantic\", \"Georges Bizet / Moritz Moszkowski\":\"Romantic\",\n",
    "                    \"Georges Bizet / Vladimir Horowitz\":\"Romantic\", \"Giuseppe Verdi / Franz Liszt\":\"Romantic\",\n",
    "                    \"Henry Purcell\":\"Baroque\", \"Isaac Albéniz\":\"Romantic\", \"Isaac Albéniz / Leopold Godowsky\":\"Romantic\",\n",
    "                    \"Jean-Philippe Rameau\":\"Baroque\", \"Johann Christian Fischer / Wolfgang Amadeus Mozart\":\"Classical\",\n",
    "                    \"Johann Pachelbel\":\"Baroque\", \"Johann Sebastian Bach\":\"Baroque\",\n",
    "                    \"Johann Sebastian Bach / Egon Petri\":\"Baroque\", \"Johann Sebastian Bach / Ferruccio Busoni\":\"Baroque\",\n",
    "                    \"Johann Sebastian Bach / Franz Liszt\":\"Romantic\", \"Johann Sebastian Bach / Myra Hess\":\"Baroque\",\n",
    "                    \"Johann Strauss / Alfred Grünfeld\":\"Romantic\", \"Johannes Brahms\":\"Romantic\",\n",
    "                    \"Joseph Haydn\":\"Classical\", \"Leoš Janáček\":\"Modern\", \"Ludwig van Beethoven\":\"Classical\",\n",
    "                    \"Mikhail Glinka / Mily Balakirev\":\"Classical\", \"Mily Balakirev\":\"Romantic\",\n",
    "                    \"Modest Mussorgsky\":\"Romantic\", \"Muzio Clementi\":\"Classical\", \"Niccolò Paganini / Franz Liszt\":\"Romantic\",\n",
    "                    \"Nikolai Medtner\":\"Romantic\", \"Nikolai Rimsky-Korsakov / Sergei Rachmaninoff\":\"Romantic\",\n",
    "                    \"Orlando Gibbons\":\"Baroque\", \"Percy Grainger\":\"Modern\",\n",
    "                    \"Pyotr Ilyich Tchaikovsky\":\"Romantic\", \"Pyotr Ilyich Tchaikovsky / Mikhail Pletnev\":\"Romantic\",\n",
    "                    \"Pyotr Ilyich Tchaikovsky / Sergei Rachmaninoff\":\"Romantic\", \"Richard Wagner / Franz Liszt\":\"Romantic\",\n",
    "                    \"Robert Schumann\":\"Romantic\", \"Robert Schumann / Franz Liszt\":\"Romantic\", \"Sergei Rachmaninoff\":\"Romantic\",\n",
    "                    \"Sergei Rachmaninoff / György Cziffra\":\"Romantic\", \"Sergei Rachmaninoff / Vyacheslav Gryaznov\":\"Romantic\",\n",
    "                    \"Wolfgang Amadeus Mozart\":\"Classical\"\n",
    "                   }\n",
    "maestro_x, maestro_y = parse_dataset(metadata, composer_era_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('maestro_x_data.txt', 'w') as f:\n",
    "    for item in maestro_x:\n",
    "        f.write(\"%s\\n\" % item)\n",
    "        \n",
    "with open('maestro_y_data.txt', 'w') as f:\n",
    "    for item in maestro_y:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load(filepath):\n",
    "    \"\"\"Based off code from the FMA github, this code loads the FMA\n",
    "    dataset from the csv file. The input to the method is the path of\n",
    "    any csv that comes from the FMA data.\n",
    "    \"\"\"\n",
    "    filename = os.path.basename(filepath)\n",
    "    if \"features\" in filename:\n",
    "        return pd.read_csv(filepath, index_col=0, header=[0, 1, 2])\n",
    "    if \"echonest\" in filename:\n",
    "        return pd.read_csv(filepath, index_col=0, header=[0, 1, 2])\n",
    "    if \"genres\" in filename:\n",
    "        return pd.read_csv(filepath, index_col=0)\n",
    "    if \"tracks\" in filename:\n",
    "        tracks = pd.read_csv(filepath, index_col=0, header=[0, 1])\n",
    "\n",
    "        COLUMNS = [(\"track\", \"tags\"), (\"album\", \"tags\"), (\"artist\", \"tags\"),\n",
    "                   (\"track\", \"genres\"), (\"track\", \"genres_all\")]\n",
    "        for column in COLUMNS:\n",
    "            tracks[column] = tracks[column].map(ast.literal_eval)\n",
    "\n",
    "        COLUMNS = [(\"track\", \"date_created\"), (\"track\", \"date_recorded\"),\n",
    "                   (\"album\", \"date_created\"), (\"album\", \"date_released\"),\n",
    "                   (\"artist\", \"date_created\"), (\"artist\", \"active_year_begin\"),\n",
    "                   (\"artist\", \"active_year_end\")]\n",
    "        for column in COLUMNS:\n",
    "            tracks[column] = pd.to_datetime(tracks[column])\n",
    "\n",
    "        SUBSETS = (\"small\", \"medium\", \"large\")\n",
    "        tracks[\"set\", \"subset\"] = tracks[\"set\", \"subset\"].astype(\n",
    "                \"category\", categories=SUBSETS, ordered=True)\n",
    "\n",
    "        COLUMNS = [(\"track\", \"genre_top\"), (\"track\", \"license\"),\n",
    "                   (\"album\", \"type\"), (\"album\", \"information\"),\n",
    "                   (\"artist\", \"bio\")]\n",
    "        for column in COLUMNS:\n",
    "            tracks[column] = tracks[column].astype(\"category\")\n",
    "\n",
    "        return tracks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "KEYWORDS = [(\"spectral_centroid\", \"mean\"), (\"spectral_centroid\", \"std\"),\n",
    "            (\"chroma_stft\", \"mean\"), (\"chroma_stft\", \"std\"),\n",
    "            (\"spectral_rolloff\", \"mean\"), (\"spectral_rolloff\", \"std\"),\n",
    "            (\"rmse\", \"mean\"), (\"rmse\", \"std\"),\n",
    "            (\"tonnetz\", \"mean\"), (\"tonnetz\", \"std\")]\n",
    "\n",
    "def extract_features(data):\n",
    "    \"\"\"This method extracts features from the data passed in, creating\n",
    "    a dictionary mapping each composer to an array of feature vectors.\n",
    "    \"\"\"\n",
    "    features = load(METADATA_DIR + \"features.csv\")\n",
    "\n",
    "    feature_table = {}\n",
    "    for composer in data:\n",
    "        feature_table[composer] = []\n",
    "        tracks = data[composer]\n",
    "        for track in tracks:\n",
    "            track_dict = {}\n",
    "            tid = track.name\n",
    "            track_dict[\"title\"] = track[\"track\", \"title\"]\n",
    "            for keyword in KEYWORDS:\n",
    "                try:\n",
    "                    track_dict[keyword] = features[keyword].loc[[tid]][\"01\"].item()\n",
    "                except KeyError:\n",
    "                    track_dict[feature] = None\n",
    "                    continue\n",
    "            feature_table[composer] += [track_dict]\n",
    "    return feature_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(composers_to_learn=None):\n",
    "    tracks = load(METADATA_DIR + \"tracks.csv\")\n",
    "\n",
    "    tracks = tracks[tracks[\"track\", \"genre_top\"] == \"Classical\"]\n",
    "    tracks = tracks[tracks[\"track\", \"composer\"].notnull()]\n",
    "    composer_dict = {}\n",
    "    for index, row in tracks.iterrows():\n",
    "        composer = row[\"track\", \"composer\"]\n",
    "        if composers_to_learn:\n",
    "            for c in composers_to_learn:\n",
    "                if c in composer:\n",
    "                    composer = composers_to_learn[composers_to_learn.index(c)]\n",
    "        if composers_to_learn and composer not in composers_to_learn:\n",
    "            continue\n",
    "        if composer not in composer_dict:\n",
    "            composer_dict[composer] = [row]\n",
    "        else:\n",
    "            composer_dict[composer] += [row]\n",
    "\n",
    "    return composer_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_learning_data(data):\n",
    "    \"\"\"This method makes the input data usable by sklearn.\n",
    "    It converts the input data into input vectors (x) and output\n",
    "    classifications (y).\n",
    "    \"\"\"\n",
    "    composer_era_map = {\"Bach\":\"Baroque\", \"Haydn\":\"Classical\",\n",
    "                        \"Alkan\":\"Romantic\", \"Orff\":\"Modern\"}\n",
    "    trimmed_data = {}\n",
    "\n",
    "    x = []\n",
    "    y = []\n",
    "    for composer in data:\n",
    "        for d in data[composer]:\n",
    "            y.append(composer_era_map[composer])\n",
    "            vector = []\n",
    "            for feature in d:\n",
    "                if feature != \"title\":\n",
    "                    vector.append(d[feature])\n",
    "            x.append(vector)\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_data(composer_dict):\n",
    "    \"\"\"This method counts how many songs in the dataset are composed\n",
    "    by each composer.\n",
    "    \"\"\"\n",
    "    count_dict = {}\n",
    "    for composer in composer_dict:\n",
    "        count_dict[composer] = len(composer_dict[composer])\n",
    "    return count_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/lucaspauker/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: FutureWarning: specifying 'categories' or 'ordered' in .astype() is deprecated; pass a CategoricalDtype instead\n",
      "  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alkan: 25\n",
      "Orff: 24\n",
      "Bach: 348\n",
      "Haydn: 44\n"
     ]
    }
   ],
   "source": [
    "composers_to_learn = [\"Bach\", \"Haydn\", \"Alkan\", \"Orff\"]\n",
    "composer_data = load_data(composers_to_learn)\n",
    "count_dict = count_data(composer_data)\n",
    "for c in count_dict:\n",
    "    print(c + \": \" + str(count_dict[c]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = extract_features(composer_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = get_learning_data(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "agg_x = x + maestro_x\n",
    "agg_y = y + maestro_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1723 1723\n"
     ]
    }
   ],
   "source": [
    "scaler = MinMaxScaler()\n",
    "agg_x = scaler.fit_transform(agg_x)\n",
    "# print(x)\n",
    "print(len(agg_x), len(agg_y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "441\n",
      "1282\n"
     ]
    }
   ],
   "source": [
    "print(len(x))\n",
    "print(len(maestro_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Romantic': 789, 'Modern': 113, 'Baroque': 541, 'Classical': 280}\n"
     ]
    }
   ],
   "source": [
    "era_dict = {}\n",
    "for point in agg_y:\n",
    "    if point in era_dict: era_dict[point] += 1\n",
    "    else: era_dict[point] = 1\n",
    "print(era_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('spectral_centroid', 'mean') vs. ('spectral_centroid', 'std')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "('spectral_centroid', 'std') vs. ('spectral_centroid', 'mean')\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOydd3hU1daH3z01mTRaqKFJb9IRpAkoIAJWVFBQQbioYLnXq6JeO9bPdr2g2EBUQECaqEgTlCqhSO81hEAgkDZ9Zn9/7EAymQkkEBIS9vs8ecjs09ZMhnX2WXut3xJSSjQajUZT8jEUtwEajUajKRy0Q9doNJpSgnboGo1GU0rQDl2j0WhKCdqhazQaTSnBVFwXrlChgqxVq1ZxXV6j0WhKJOvXrz8ppYwNta3YHHqtWrWIj48vrstrNBpNiUQIcSivbTrkotFoNKUE7dA1Go2mlKAdukaj0ZQStEPXaDSaUoJ26BqNRlNK0A5do9FoSgnaoWs0Gk0podjy0DUajabI8aTDgW/h1F8Q0xTqPATW8sVtVaFxQYcuhPga6AuckFI2DbFdAB8DfQA78KCUckNhG6rRaDSXhP0oLGijnLovE4zhsG0s9FwJMY2L27pCIT8hl0lA7/Nsvxmol/UzAvj00s3SaDSaQmbDv8CVrJw5gM8BnlRYO7x47SpELujQpZR/ACnn2eVWYLJUrAHKCCGqFJaBGo1GUygk/gzSl2tQwqm14HMVi0mFTWEsilYDjuR4nZA1FoQQYoQQIl4IEZ+cnFwIl9ZoNJp8YrCEHhcGEMaiteUyURgOXYQYC9moVEr5uZSyjZSyTWxsSLEwjUajuTxc8yAYwgLHDGaodisYSkd+SGE49ASgeo7XcUBiIZxXo9FoCo9rX4fy7cAYoX5MkRDVENp9VtyWFRqFcVuaB4wSQkwDrgNSpZTHCuG8Go1GU3iYbHDTcji1Ds5sgah6ENsJRKggQ8kkP2mLU4EbgApCiATgZcAMIKX8DPgFlbK4F5W2+NDlMlaj0WgumfJt1U8p5IIOXUo58ALbJfBYoVmk0Wg0motCl/5rNBpNKUE7dI1GoyklaIeu0Wg0pQTt0DUajaaUoB26RqPRlBK0Q9doNJpSgnboGo1GU0rQDl2j0WhKCdqhazQaTSlBO3SNRqMpJWiHrtFoNKUE7dA1Gk3JwnEMVg2BGWVhVmXY9EKp6Th0qZQOVXeNRnN14ElXjZ6dJ0B6wQPs+gBS4qH7b8VtXbGjZ+gajabkcGAyuM8oZ34WnxOSV8DpTcVn1xWCdugajabkcHIN+OzB48IAp//Ofu33ws6P4KcGMKc6xD8BrlNFZ2cxoUMuGo2m5BDTCIxhalaem8hrsn9fdR8cnZ/t/Pd+BkfnwS1bwRRRNLYWA3qGrtFoSg51HgaDJXBMmCGilmonB5C6E47+FDiT97vBmQwHvisyU4sD7dA1Gk3JIawi3PgHlGsNwqScedWbocfv2b1BU9aBMAYf68uEE8uL1t4iRodcNBpNyaJsc+gdD54MMJhUCCYnthqhjzNYIKru5bevGNEzdI1GUzIxRwY7c4CKnSG8SvAs3WCBuiOKxrZiQjt0jUZTuhAG6LEMKnRUTtwYphZMuy0AW1xxW3dZ0SEXjUZT+rBVhZuWq1RFnwPCq2XH2Esx2qFrNJrSi7V8cVtQpOiQi0aj0ZQStEPXaDSaUoJ26BqNRlNK0A5do9FoSgnaoWs0Gk0pQTt0jUajKSXky6ELIXoLIXYJIfYKIZ4Lsb2GEOJ3IcRGIcRmIUSfwjdVo9FoNOfjgg5dCGEExgE3A42BgUKIxrl2exGYLqVsCdwLjC9sQzUajUZzfvIzQ28H7JVS7pdSuoFpwK259pFAdNbvMUBi4Zmo0Wg0mvyQH4deDTiS43VC1lhOXgHuF0IkAL8Ao0OdSAgxQggRL4SIT05OvghzNRqNRpMX+XHooQQQZK7XA4FJUso4oA/wrRAi6NxSys+llG2klG1iY2MLbq1Go9Fo8iQ/Dj0BqJ7jdRzBIZVhwHQAKeVqIAyoUBgGajQajSZ/5MehrwPqCSFqCyEsqEXPebn2OQz0ABBCNEI5dB1T0Wg0wfh9qjmFzP2gr7lULujQpZReYBTwG7ADlc2yTQjxmhCif9Zu/wKGCyH+BqYCD0qp/1oajSYHfi9sfAZmxsDMsjC3FhyZW9xWlSpEcfndNm3ayPj4+GK5tkajKQbWjYL9EwObNxtt0O1XqNil+OwqYQgh1ksp24TapitFNRrN5ceTDvu/CnTmoF5vea14bCqFaIeu0WguP44kEHn000nfXbS2lGK0Q9doNJcfW1wei6ACyrUqcnNKK9qhazSay48pHJo8p2LmOTGGQ7NXi8emIsIv/Ww5voVtJ7ZxudcsdU9RjUZTNDR5AcIqwba3wZmkZu3h1WDf11BvJMQ0Km4LC53VR1YzYMYAUl2pSCmpYKvArHtm0arK5Xkq0VkuGo2maPFkwML2kHEQfJkgjGCwQodvocYdxW1doZHiSKHWR7VId6cHjMdYY0j4ZwKRlsiLOq/OctFoNFcOe8ZDxn7lzAGkT2W7rB0Gfk/x2laITNs6Da/fGzTukz5m7Zh1Wa6pHbpGoylaDk8HnyN4XPrh9Kait+cykZSRhMMb/D6dXidJGUmX5ZraoWs0mqLFFB16XHrBdHFhiCuRLjW7hAyrWI1WutS8PIVU2qFrNJqC4/eB4zj4XAU/tsEoMEbkGjRARE2Iblgo5l0JdK/dnbZV22IzZ2f22Mw2utXqxnXVrrss19RZLhqNpmDs+Rz+HpNV9WmA+o9C87fBYMzf8XG3Q71/wO7xYDCrMUtZ6PoTiFBq3SUTgzCw4P4FfL7+cyZtmoRRGBnacijDWg1DXKb3qbNcNBpN/jkyC1YNDtZjqT8KWr5TsHPZEyB5FYRVVFouwS0UNCHQWS4azZWMPQF2/Rd2fADpe4vbmvOz5ZXQeiy7/wc+d8HOZYuDmndDpRu0My8kdMhFoylO9k2C+EfU71LC5hegyX+g6fPFalaeZCaEHpc+8KSBUfe1KU70bVGjKS4cScqZ+5zqx+9S/257A85sKW7rQlO2RehxcxRYyxWtLZogtEPXaIqLo/MI+V/Q74ZD04vcnHzR4u0Qeiw2aPGuDptcAei/gEZTXEg/wf3Wzw5doQ2/KrSDHr9DpR5gKa9m7B2nQJ2HitsyDTqGrtEUH9X6w4angseNFqhxV9Hbk18qtIMei4vbCk0I9AxdoykubFWh1YdKQtZgUSJVxnBo+K+8Y9UazXnQM3SNpjipNxKq9ITDM1Xpe7VboUyT4rZKU0LRDl2jKW4ir4HGzxS3FZpSgA65aDSawuXwjzC/MUyPhAVtIWlpcVt01aAdukZT1PhcsH8SLL8V1jwMKeuL26LCY/9kWD0E0naANxNS4mF5X0haUtyWXRXokItGU5T4nLCoE6TuzOrWY4BDU6H1x1D34eK27tKQEjY9G0IawAEbn4WbtXbT5UbP0DWaomT/JEjdkaNbj185wPVPqNZsJRlvJrhOht6WtiPE/nYVntk/SenZaC4ZPUPXaIqSwzODZ7AABhOcXA1Vbip6mwoLk001qPCcCd4WUT3wdfJKWNZHzeqlX2nBNBkDzV4qGltLKXqGrtEUJZayocelH8x5dPIpKQgDNH42tDRAs9eyX/tcsKyvEvPypqunFb8Ttr+jHL3motEOXaMpSuo/GuzwEGApB+XbFotJhUrjZ6Hpf8AcA8IE1orQ5n9KJvcsx5dmyR7kwueAvV8Vna2lEB1y0WiKkkrdoOmLsOU1VR2KVDPzbgtKh7iVENDkOZVX781UIZjc3Xl8zjwOltlrC5qLQjt0jaaoaTIG6gyH5D/VzLxi55LnzD1pkDAXvBlQuSdE1QncLgxKUjcUlbqB9ASPmyKg5j2Fb+tVRL6+RUKI3kKIXUKIvUKI5/LY524hxHYhxDYhxJTCNVOjKWWEVYDqt0OlriXPmScthdlVYd2jsOFf8EtT2DQm/8dbykDr/yndGpE1pzRFQsVuSvpAc9FccIYuhDAC44CbgARgnRBinpRye4596gFjgI5SytNCiIqXy2CNRlOM+Jzw5+0qnJKTXf+FKr3VDSo/1B0Kse1h30TwpELcbVC1d8m7uV1h5Cfk0g7YK6XcDyCEmAbcCmzPsc9wYJyU8jSAlPJEYRuq0WiuAJKWhJZq9zlg/9f5d+gAMY2h1XuFZpomfyGXasCRHK8TssZyUh+oL4RYKYRYI4ToHepEQogRQoh4IUR8cnLyxVms0WiKD78HRKgNsuBNojWFTn4ceqg/X+57tAmoB9wADAS+FEKUCTpIys+llG2klG1iY2MLaqtGoyluKndXTj03pgioNbDo7dEEkB+HngDkLPOKAxJD7DNXSumRUh4AdqEcvEajKU2Yo6Hd51kLmmZAKGdepQ9U61vc1l315CeGvg6oJ4SoDRwF7gUG5dpnDmpmPkkIUQEVgtlfmIZqNJrLgDdT6anYj0D5dlC5x4UXJmvfDxU6wIHvshY0+0HFG4LzzTVFzgUdupTSK4QYBfwGGIGvpZTbhBCvAfFSynlZ23oKIbYDPuDfUspTl9NwjUZziaTugEWdwe9SQlkmG8Q0hR5LwRR+/mOj6sC1LxeNnZp8I6Qsnu7ibdq0kfHxWk5Toyk2fmkBZzYTsCRmDIPGWiTrSkYIsV5K2SbUNp30qdFcjTiSIG0nQfkNPicc+KZYTNJcOtqhazRXJed5Mi+mp3bNpaMdukZzNRJeBaIbEJSVbAiD2kOKxSTNpaMdukZztXL9FKXPbopEpR9GQtlrlVKipkSi1RY1mquVMk3g1kNwZCZkZqUtVrlJ66mUYLRD12iuZsyRcM2DwePuM7Dj/1TLPHM01B8FtQfrXPMrHO3QNRpNIN5MWNBGNW72u9TYukfh1BpoO754bdOcF/1spdFcjXgdsOczWNoTVg6EEyuyt+2fDI5j2c4cVCehfRMh83DR26rJN3qGrtFcDUgJR3+C3f8D92mwJ6p//Q5AQMI8aD4WGj4JSYvAZw8+h8EMp9ZCRI0iN1+TP7RD12iuBv5+HnZ9kkfPTqkc+N9jVDw9oqbqJCS9wfuFVSkCYzUXiw65aDSlHXsi7Pzwwg2YDRZIXgX1HslqYJ0DYYSwyhDb8fLZqblktEPXaEo7J1cFO+hQSKn6fUbXh84zwRqrctMNYVC2lRLt0lkuVzQ65KK5epB+QFx9Tsman2YyQhUZVWivXla9GW4/Bum7lFPXcfMSgXbomosiOTOZX/b8gtFg5JZ6t1A2vGxxm5Q3abvhr5FwYjkYTFB9ALT9n5qNXg1U7KyctTeDIA0XUwQgwFoeuv0WWFRkMKq+n5oSg3bomgLz9caveeyXxzAZ1NfH5/fxzW3fMKDJgGK2LASuFFjYQWV0IMHvhiMzIG079F5fMmbrfi/seA92j1c54lVvhhZvQ0T1Cx8Lykn3WALL+qrccoNRhVdaf6w0XSxloPx1JeOz0JwXrYdekklIgJQUaNgQLPmIkRYCB04foMn4Jji8joDxcFM4B544QKXISkViR77Z8T5sfik4Dc8UCd0WlIxFvhX3wNH5Od6DEazloO8ONbPOL1JC6nbwpEG5VmC0XhZzNZcXrYde2khOhq5doV496NQJYmNh8uQiufQP237A68+dzgZCCGbvnF0kNhSIM1tC51RLCWm7it6egpK+D47Oy/UefCp8svfzgp1LCKXfEttBO/NSinboJZH+/WH1anA6IT0d0tLgkUfU2GXG6XXik76gcZ/fh9PrvOzXLzDlWoPRFjwugJgmRW5OgTnzN4gQT18+h0ox1GhyoB16SSI1FcaNgw0bwOMJ3OZwwAcfXHYT+jfoT5gpLGjcIAz0rX8Fdn2vPSRLHjbnYp8VyjRX6oIXQvpVyfuvrWBefdj4XFY8voiIqB2iwAeVhhjTqOjs0JQItEMvKUyaBFWqwL//DW538HYp4fDl19loVaUVw1sNx2a2IRAYMGAz23im4zPULVf3sl+/wFhioPdfENdf5VObo6Hu8KyMjnwsAv41EuJHw+mNkLEHdn2khKu8FyjSKSzKtYQyzYLzyA0WqP9Y0digKTHoLJeSwK5d8OijahaeF1Yr9OpVJOZ81Psj7m5yN9O2TsNkMDGo2SDaVA25RnNlEFETulxEfD/jIBz4Fvw5Qkl+l+rHuX8y1H+k0Ew8L90WwNqHlRaLlBBdD677Sr0vjSYH2qGXBL75JjjEkhOLBcqVg8cfLzKTrq9+PddXv77IrlcsnPpLCVL5c60N+OyQtLjoHLqljKrc9DrUDeVqyZ/XFBgdcikJpKaCN1Qc1aDCMKNHw6ZNUKFC0dtWmgmvSshmysIMkbWL3BxM4dqZa86LnqGXBG69Vc3SM3PFbS0WWLMGalw5Zdkur4uZ22fyx+E/qF2mNg+2eJDKkZWL26yLI7ajKrzJ2A85M3sMZqg3svjs0mjyQDv0ksBNN6mfxYshI0Mt5oWHqwXSK8WZ+/2kZabQfnIXjqQdIcOdQZgxjLF/jmXh/QvpUL1DkZvk9rmZvWM26xLXUa9cPQY2G0i0NTr/JxBCCVL9eRec/lspDpqjoMM3EHUFLgBrrnp0pWhJwe+HefNg2jSw2eChh6Bz5+K2Sj01PPEEfPcdL3Ry8f71Apcx8DtVO6Y6+7oMRDgSoEovqHnPZS9sOe04Tfuv2pOYnkiGO4MIcwRWk5UVD62gUexFpPvZj6pinqh6uomyplg5X6WoduiaS+PGG2HFCnC5qPM47C8XvEu4gO21TNQyeZUYVERt6LlaNSi+TIz6ZRRfbPgCty87xVMgaF21NeuGr7ts19VoLje69F9TqPiln6SMJBxbN8GqVeBSvSetwQWkan/AilrU9XsymXdsF4O/68wj8x9h3dFg5+r0Ovl649fc8cMdPPbzY2w5vqXANk7fNj3AmQNIJH8n/U2qM7XA59NoSgI6hq4pEFO2TOHJBU+S7k4Hn48hN8N/5ypnPiIeXugB9hw1MAagmQWqmMAvlcT2UruHDLkJw5HNTN48mVdveJWnr38aALvHTvsv27P/9H4yPZkYhZFJf0/iq/5fcW/Te/Nt51klyFAYdMhEU0rJ1zdbCNFbCLFLCLFXCPHcefa7SwghhRBXcJWJ5mJZsn8Jw38aTrI9GafXiVN6+LaRh5FZFf+j1sFN+8HmAZs0E2WOoIpJMD2rDeWvdlhih4ysKJ9f+rF77Pzn9/9wPOM4AJ/Ff8belL1kelRGj0/6sHvsjPhpBC6vK7dJeTKk+RDCjIESBUZh5Prq1xNljbroz+DAAXjpJRgxAn78MXQ2qUZTXFzQoQshjMA44GagMTBQCBGkei+EiAIeB9YWtpGaK4PX/3gduydQudBhhmnNINUKJj/M+UGw6ocoPuwylmkDpnOweSNqm9XX7McMyAyxZGMymFi0fxEAM7bPCJLmBaXmGJ+Y/zWXl7q+RMsqLYm0RGIxWoiyRFE1qiqTb5vMrpO7OHD6QAHeuWL+fGjSBN55B774Ah54QK1Lu/K6z/h8SgXzhhugWzf49ls1VkD+/lutgd9wA7zxhlJMLiz2puxl47GNIRU0NSWP/IRc2gF7pZT7AYQQ04Bbge259nsdeBd4ulAtvFpxu8FoVD8AO3fC1Klq/M47oU3RPwQdOBPaCZqMFpKq24g56oLu3Wn+wQc0r19fbaxcH5Z0A3cqUUYnBjz4cx0vEESYIwCIscaEvIbP7ytQyqHNbGPl0JX8cegPNiZtpHaZ2kRbo+k4sSOnHafxSz91ytZh1j2zqFe+3gXP5/HA4MGB6guZmbB5M3z5JTyWW1ZFSvV3Wrw4u35g3TqYNUv95LOZxNy5MGiQEtb0+2HtWhg/HjZuhEqXID1/8MxBbp12K3tO7cFkMGEymJh460RubXjrxZ9UU+zkJ+RSDTiS43VC1tg5hBAtgepSyvnnO5EQYoQQIl4IEZ+cnFxgY68KNm2Cdu1UnrnNBkOGqClhq1bw5pvw7rtKC/2pp4rctPZx7UPGn90m+OmbFziUuENNY886c1D52v0PQucfGdrxZawhlBqFEPSu2xuAUe1GnXPu57YjqBZVjaYVmxbIXiEEXWt15cn2T9KuWjv6Te1HQloCmZ5MHF4H25K30WVSFzy+88gqZLF+vXKoubHb4fvvQxywalWgMwf1+6JF+ZY59vlg+HB1jbPXdjrh5El46618nSIkfumn+zfd2XpiKw6vg3R3Oqedpxk0axA7kndc/ImvFHbsgL59IToaataEDz8M/ccrheTHoYeaSpx7cBZCGIAPgX9d6ERSys+llG2klG1iY/PTuPYqwu2GhQtVw4p169QX0O2GH36AMWPU1NDrVeN2O3z+Ofz1V5Ga+ErXV86pLObE6/MyZskYGv6vIeP/Gh98oMEIVW6ieesXeO+m/yPMFEaUJYpoSzQx1hh+HvQz4eZwAG6pdwtPXPcEVqOVKEsUUZYo4qLjmD9oPuISWqRN2jQpSMddIsl0Z/Lr3l/Pe6zT62Rz+lI8VZeDIdj523x7wXkicHDZstBiak6n2pYP9u1Tf+rceDzw00/5OkVIVh5eSbI9Gb8MdHJur5vx8SH+fiWJgwehfXv45RfVK+DwYXjxRVUrcRWQn5BLApCzeWEckJjjdRTQFFiW9R+uMjBPCNFfSqkTzfPD99+rZ3a7PViEK5RULoDDwcZZ4/jfsQkcSTtCn3p9GNZy2CUt+F2IRrGNWD1sNc8veZ4/D/3JGdcZAPz48fv9ePHy1MKn6NugLzViAitY1yeuZ8ySMaw/tp46ZevQq04vutbqSs86PQP01YUQjO0xllHtRrHqyCoq2CrQuWbnS85MOZJ2JGQDDq/fy7H0Y3ke9/Punxn04yAQ4LwD8Jpg2hw4rIq6IqwZjLz+P/DzUujzN4RnyRyULw9hYcEe2WpVQmr5ICYm70XXc6fw+yBpEdgPQ7m2Sm73AhzPPI4hxFzOK70kpCbky7YrlvfeUzfSnPU1druKi738cqnXO8rP/5J1QD0hRG0hhAW4F5h3dqOUMlVKWUFKWUtKWQtYA2hnnl/WrVMpE6mp51dUzMW0ptApbAqTNk1i0f5FPL/keVpMaEHqvm0qRrt6deCXupBoWrEp8wbO487Gd4bc7va5mb5tesDY+sT1dJnUhUX7F5HiSGFb8jY+W/8ZxzOPh2yWAVAlqgp3Nr6TrrW6FkqaYdeaXYm0hC5kykuWIDE9kQEzBpDmTiPNlYa0pIEtBe7rQ3hkImFmB4M7TebONtNU04ttb2YffPfdSjwtB3YzJIXZ8Vufhe3vXvDvU6kSXH89mHJNuyIisiJumUdgXh1YcTesfwoWdVKNoP3n/x51iOsQlKMPat3hbOirxLJmTej/R1arkqEu5Vzwf4qU0guMAn4DdgDTpZTbhBCvCSH6X24DSz0ffRT0aO42wgftodkj0PQR+L8O4DIGbh95i8QuvPizlhgdXgeJpw7y8fBrVfpFz57QqBGpB3aQlJFEYVcEny/jZM+B+WDPfogbs2RMUHaM3WPnucXP4fMXPOvjYrij0R3UKVsn4AZiM9voW78v11a6NuQx32/+PigsARBmcXLvsHvY8nYzPh36mFrflB5I/CV7p3Ll1GN/bCzO6DCG3Q7lnoXao6Hq0TSmr/wPbB17Qbt/+AFatFDLKTExatL/6KMwcCCwciA4EsCbriR9fXY4vhR2fnjec1aLrsbItiMD1irCTGFUj67O4OaDL2jTFU3jxkE3UkClItUs/frx+SosklL+AvySa+ylPPa94dLNuoo4fDhgpiaB3vfBmjhwZBXovNQN5jWA5ZPUgsaWigRligA4DX7Gt4I2CRm0SoSH2u5i6aQmCLOFuOg4Jt02iU41Ol20qcmZyaw4vIJy4eWoFJF3ikWb9NVq5tj8DWj0r5DVoACZ7kyS7cnn1BillHwa/ylv/fkWxzOP07xScz7o9QGda166Zo3ZaGbl0JV8uOZDpmyZgtVkZWTrkTzc6uE8j0lxpODyBeckSuGlWb0V1C2ba4M117pQ585w7BjD3inHbI+Ts2dy+uChY24qxb9J1ybPKvXGPIiNVQ9xW7dCYiK0bKnGcJ2ClHWBKpCgeo3u/RwaP5P3hwF80PMDOsR14JO/PiHNmcaAJgN4/LrHsZlD9F8tSfz73+oJNWeoKywMeveGuLjis6uI0FouRYGUqgrl//5PpSjcfDM8/7zSMh87Fl5//Vwy87Ja0G8gZOTSrop0wZxp0OMA7C0H147MdviB14JIN/gM4BEq5HuWCHMEWx/dSq0ytQr8Ft744w3G/jkWi9GClBKL0UKqMxVvrn6XZiClDkQaQBrCecTch8+3zkKG0hUHdj62kwYVGgDw2vLXeGflOwGzeZvZxu8P/E67avno/1nILDu4jL5T+p4rcjpLuMHAXzUMNDXneO/GCKXCWCMwFJXiSKHae+Vxhnj7PW2C30YnQVjFghvnOAZzrwluvgEQHge3Hwkev1pYsgRGjlQLpCaTyjf9+GOVOVYK0Fouxc1rr8GDD6ok4n37YMIE9Rx94oR6fi5f/tyuq6qrYp3cZFpgZdY6Y90UaHgSjKGiFULdDBymQGcO4PF7+HTdpwU2f/H+xby14i2cXidprjTS3emkOFKwmCznqjHPfpHKGODxZDjogdlpTr7bMS9PZw7w0u/qQc/pdfLuyndDhmbO7lPUdK3ZlW41b8Toz5FG6Y6gQ8QQmlZtD8ZwMMeAMUzNiHM48zRXGuPXjecf8/+BDJkoBvs8gCV/C6RBhFUO3YLOYIGad1/cOUsLPXrA7t2qAistTWWElRJnfiG0lsvl5swZePttla52Fo9HLYJ+/LGaoW/apHTNnU6qpkOYBzJzzdBtHqianv167jToORiORCtnH+QzQvgQt8/NrlMFXxgat25ckKOVSAzCwAe9P2B6/Mf8eXwHfiDZD5PTYHYGXGuRZB5sDdsGgMEHTadC1Y0B51lyYAkAx9KP5en4/zj0R4FtLgyEEFhm/4hh/wx8jSaD3wwbh7L6SH/++FXQpc9eNVMuc61qRp3FoTOHaPdFOzI8GUGf21mMwPVVW8N5NGcuYBxc/x0s6a7i90viX3cAACAASURBVD4nmCJVQ46mL17cOUsTQkDU5cv4ulLRM/TLzZYtaoU9Ny6XKjIBFRT96COw2bhrO5j9BHU+M/mh2wH4tS5srGYkzmlm+zgVhjHls2bCJix0XX4Ihg1ThS/55IzzTMhxgzBQs0xN/ko5TM68Ah+Q4Yf4ee/D5MWw9glY/RRM/BOW/SfgHLE2FXeuFFkpzwIfp9fJoTOH8m1vYXHiBPw834hn470w5ReYNhd23YrDLlRhT1RdqNg5wJkDPPbLY5x0nMzTmQvAZgrjP31DVSQVgPJtoP9eaPYq1B0BbcdDn81gyR3c11wtaId+ualSJXQuuRBQq1b26xtvhMqViXTDskkqrGJzq59rUuCO7dD0Ubj3Lug8FJq/Xo2kPl24MbIZLTzlELmdetANQVAmzcPQiZtg4kTVAWnshbMsAO5qdFfIxTKf30fZrfsQ3uDYj/dYC+zrRoInAqQRpEn9vmIMnKqjPgIEr3V7DVCx8rjo0ItW4eZwNiZtDLntbGph2Bth2MbaeGjOQ6Q4CkfsJDEx9L0YlEhXXvy277eQ2TEA5cPLc1vD21k7YgP1KtQPuU+BCKuowj3tJkDtwSr8o7lq0Q69KMjlFTZUgadvNvBkHwOrjmTpiXfqpBZxgObHYef/4JNf4Jbd0DBZCWA5zZAWBplGH9sch2l+ww7ajQ6jfpveGIyGQCeeFXIxCAOVjDEM3WJk/QRJjAu1SGu3K6WnxEQuxNCWQ2lQvsG5NDeDMGAzhfPJiihq/+MZPJ4QC3M7bwVvHt5wt5Jn7F+/PwOaDDg33Lde36AqVPVWBNWjqweNOzwOrvvyOubsmIPL58LhdTBlyxQ6T+ycp0O9EMsPLqf7N92J+yCO5zb3xV1+Q9A+JpP6c+WFOY+slTBTGCefOcmse2ZdXNckjeYC6Bj6xSIl/P47zJypHPbgwUpvJSdnzqgy5LS0c0OvdYF3OoHT5EMe+IEvvpzJw6l1+PjEiXN6E34Bd94NS67JynaRBMXE/fhJtieTbE9mw7EN+KQ/ZNw83BTOxIR2bDmxiGlN4a7tEHfWHJNJ6Y0MGRJo89SpKp2yQwe45RbCzeGsHraaKVumMHfXXCpFVGLkt9tpuXgteDz02gO/1lOaLmcxWfxgEnhzR1GEH0wqo2fh/oWku9LPVbeOvm40X236KiBUYTaYqVeuHq2q5PpsgZnbZ3LGeSYg08btd3Mk9QgL9y0scJHMvJ3zuPfHe8+pPSamJ2J64Hes3y3GtVcVHxkMKif8hRfyPs+9Te/l+y3fBxTvWIwW7m2Sfz13jeZi0DP0i0FKGDoU+veHTz+F//5XTdnefjtwv6++ClBW2lcW3uqsGkD4DSANYDf4+DJiN+srZc8o59eHxXVypC5eQMIkt0ZJThxeB3dUXMqL3eC5HlB/NEw+W0cjBETmqJ7cuFGFgZ5+Wr2X++5TQmGZmVhNVh5q+RBz7p3DhJs+puUc5czdRsg0g1egbjxSzaifHFYFsynE10sKaDQLUCJRC/ctPLepXvl6/DTwJ2rE1CDcFI7FaKF77e4sHLwwpI7LlhNbyHBnBI27fC62J+cWAz0/UkqeWPBEgHSvROLBTs2Hn6Z5c6hcGQYMgPh4qF0773N92OtDmsY2JdISic1sI9ISSePYxnzU+6MC2aTRFBQ9Q78Y/vwTZszIVtLz+1W156uvKicoBDz8sBLbypHnP6th6NM5TTCnIbTOkhSZ2jQrc6UwkOAUvoC/9D/6wc17IdZgIL17J06nHqZaZFWMAweq7JuzZGTA9u1K4fHVV7PHvd5zut4fX6fSKf05KlkBlqdN5OOPH2H0aD8uefZzMsJtD0KkErLyhChR7167OwefOEhCWgKRlkjKhue9wNc4tjGR5kgyPIFO3Wq00rBCHh92Hji9To6khc7dPuLdiH1T/s8VExZD/Ih4/jz8JzuSd9AothGda3S+JHExjSY/aId+McyeHVoGz2BQ8rFvvaVi01nOfFktGHkL7C6vJqi5MfohzKsmuK/cADMaEzLMEnLsPKhJc3As2Sjhx9ZhLB/Ultn/q4FRGIkwhvFJeBr35N7Z6VTiYTkd+qlT5379onVwgZNEsvn4Zvo9mUSTThl0feFdvNIJ9eeD7XT2flLSs07PYLuFoHpMcMw8N3c3uZvnlzyPw+s495RiNpipHFmZXnV6XfD4nFhNVmxmm2qtl4tKkQUXHhdC0KVmF7rU7FLgYzWai0WHXC4Gmy278URODAalxXzmzLkZ7NaKcMsg2BWrQiyhHLJRwr1b4Z2OKr7uM4be73zOXPizF+MMUuWy99pvCM5+AQgL4/NBDZlzcgUunwu7106yK4Wht3hZkVW8JIFZjaDHEGjTJ4F3V76bHd74+mu2VTLwcD84nEfPCSEEHp+HDg3rENdlEbT4NsCZA9zf7P7zFh1dCJvZxtqH13JzvZsxCiNmg5nbG93OqmGrMBpC/H3Og0EYQpa+28w2xnQac9E2XlFkHIAtr8OGf8Px3y+LeJumeNGl/xfD9u2qY1BuvWubDZ55Bt54AydeXugOn1wHnlCOXKpiIb+A//4KS2srBcWCzMCREOFR8etBO0zc8OIXzJv5Nqd+6UTy1hE4CedQx6l4O34MluwnCqsXMJtxSU/Q+frsgZ+nwL9vgk/bZod+wkxh1Clbh3XD17HiyTu4rcwCXMasm0+IJ4f65eqzc9ROhBBsOLaB7t90x+1z4/Q6MQkTNovt3OJny8ot+eb2b4LDJO4zYLCC6cJVfme/x5cS1vD5fTy98GkmrJ+gbggSnuv0HM93fr7kh0sOTYc1DyrtF78HTDao3As6zwDdNLtEcb7Sf+3QL5bx4+Ff/1KZIkKoGfnMmSqu/uCD9O2fyZJrVKphKMLd8OQaGLEebrkPtsdSMGeOmoV/PQe6Hw+n0sNPwFtvMdj6A7Pct2BHLXYaDHb8FfZCh3cxZsZiilvJc/vW8WEnSAuRVdgoxciiGWHUHZaJM7dsqzmCj3t/zGu/Psdh78nAjVlOPdxoxWS0sPSBpbSpmv2dS3OlMWPbDI6mHWVc/DhO2U+dC5MIBGXDy3LgiQOqzVzySlg7DNL3q8+2Wn+47guwlCnYB3SRZLozScpIolp0tTzlfUsUngyYVUmpMebEFAEdvoXqtxePXZqL4nwOXcfQL5ZHH4W77oIFC1TaYsWKamznTnaXh6XnceagqilbrLyJ+2q0ZnvSASg7B8z572pv9UDjUwa2VBOc7t2Wgc//k6Qd8KO7Pw6yZ7R+vw1ONIP5n+PDgMXnZZ1YiqfjHVlWZGMymOjc7QFWNY3CnPgp2fqAikxPJj/u+JHjMjjOjIBwv5GxPd9icPPBVLAFNhKItkYzrNUw5u6ci8PjCMjMkUicXidTt0zlHw1uhKW9wJd5diMcnYd/6TEWG1aweLHqUXD//VC1ar4/rgIRYYmgTrk6l+fkxcGJZSBC/Ff3ZsLB77VDL0VctQ797IPJJT1JV6yocriPHFE6zBkqxrw9Fsy+0CJb6uLgNli478bqeBc+B4cE/PYhDOsI5Q4E7BcqVGPyQxRmdseZ2VDZjs0Uz5hxdXnc9DdUPgUY4XgzVaGp3iX4VGzYASyTPbhp+sMsvv8r7AaVw23AQITJxpgbXlRl9lO/AnegQzcJEzViauQZ944rX4eYHU/RYyScPq3aOr70kkr3O8v+0/tDStLaPXb2puyF3TvAH1hZ6/X4uOXZV1i1z0dGphGrVa3RzpoFvQq29nl1Is4zszDkUfylKZFcdcGz48fVxNpqBYsFbr8djuXdgSw0O3cqPZT27WH0aJXV4sp2Ug1PgifUmlxWnjYCMLnxtpiiavnd0WCvCLO/veClI9xwyx5BhhkyvOoR2u61k+ZK483TTXAM7QIPdYZ/VYOay4NPUHY/9uYz2RrRlM+jB9L8tJXKGYJ7dhqJ/6+TWuOn0KlGZ5Uu6IyGjQ/Aqn/CsRZ43RaqJz5O33p9sRgDU1tsZhvVVk1n9GjYvFnd4778Uul3p+SoxG9VpVXQsQCRlkgVokndocSmcjD5zyGs3NWBjEz1obpcKslo4MACNXm6eql0Q+iZizEC6jxU5OZoLh9X1Qzd41HFj0eOZPdqnD9fdXTfsydv3Y4AVqxQYvlOp4qbb9igpvs5mj82PAmdD8EfNXOEXc5OanP+vzI7ocZKqLADTjaCo22UE7WmISRYfcFhG58BtsSZcBLsyfxme/b5rRkw5Cb47lc40EMZ0OcxaDkR/CYOCsnTqXb+sUmyqA4cNhl5zPMOK18YhuNFQb02K2FTGXWc3wLCC7aTjPXU5NfFkzjl6MdfR//CYrTg9Dq5u8bjTH3t2pz3NTwelfDz6Xg/L7wgICuVr2nFpmxK2nSux6fFaKFKZBVub3Q7yN2Q/IdSD8xi8orBZLpySNie/Sx8qk92x475+LtdzRit0GUOLO+nXksfIKHeP6BSj2I1TVO4XFUz9J9+Uv0lcjbe9XpVeGDOnHyeZORItfCZlZaIxxOyk+/sH2DoRrX4afBDWQehFz19Zii/O+uFQPgFVi/8NAVu3wERLkCqc9jc8MZSsFSvFdq23Oc3eOD+3nDdR9BkBrSYrG4i1gz8lkyOGyVv3ACrylZk5e+/s/D0cDKJwC8Fu9bFgScSPFHgs4I3AtJq4nTC5K+iWPbgMjaN3MSMATM49OQh7i7/FmFhwW/Q6YQlU5fBjGjY+CxCelkyZAmPt3ucypGVibXFMrzVcNY8vEbN3Os9omRgyX7EMechJyklmM8TTSgwW7dC165qoTsyUnWKz53JVFKpdAPcflQpMrZ8D27eDK3ev8SYo+ZK46qaoa9aBekh1vMyMlT6+AVxOs/tmEwFEqlKXfYSQXCRkc0D49bCuM0gE+GlrvDe9eDK7YCMHkhujMBH2TIb+NeqVIZvgFg79NkLi6+BmY3V+Yb8DS1PW/Hf25KX/ftxGHIsaoaKtwvA6IWbnkMca4G0BHbekYDPZ4HvF0BSixAnCEZKSEpSv9cvX5/65ZViYFxc6PCH0eChbqU94M2A3Z+A8wS2DhN556Z3eOemd4IPCKsAveNh0/Nw7FcwRTH8wUxWvyTJzAy0LyJCZY8WCkePqqn+Wd2dzEzVGGHPHtUbtDRgjlaKjJpSy1UzQ58/X/WTCEn11SyMHkj3b7rz4eoPQ+qDAGA24zBHczc/UJ0jdOEPynOKShwjhtN0YRlruA7KAq8C/we8AmI8POqCMB+BhT6eMNh3I9aUOMx46Z5ymBtXtCU26/4ggJv2w4T58OFv0DIJcLt5wtOajta6RLjB7M3qXHQeXxxudFGmUh7aJj4LGLznP0EODAbo1y94vFkzaNJEBs2mrSY3T/T+b9a1HHBoGjiTz3+RiJrQ8Xu4KwVuO8SAp/pz112C8HAVFouMVA2T587N7gec6kzlROaJi2+G/ckngU1IQL1etkx1v9FoSgBXRR66260SUnLKlJyj9QTo9U+ExYFEEm4KJy46jnUPr2ftn1H89RdUr64WUiMi4IEGa5i+uzlOQhe7mA2ZLH2sB53arA18/nHBrvfhiRbwe201475hfV3W//4zJ3w1cBGGwEcYTt7lWUYxLuT5JZD48MtEtm3I1vGPsibyDMdsko/aZxX5hCDKDVFhkBgqcuGKhHdSVDeefFCtmpq0BnX02rCBk32GcN/Jj1ju64zR7CUmIpUvhz9Mnxa/5viAYqD7IijfNl/Xy8mWLUrgMjpaLWNUrgwnMk8wZPYQfj/4OwJBjZgaTLptEtdXv75gJ+/VS2nv5CY6Gr79VgmxaTRXAFd9Hnp8fGCV8x38yL94j6PVjjCo93G8Zt+5NUuH18GRtASuHfoZpxaMIrPVWESriTy03cMdDe/kpxOv487DmQN4/BGMWfQmf7bPtdhkggbtYMHE7KHvuI7fqIYLVbwiMeIwWHmySVt+bWyinNvLiPXQ+bDa/1d6M5wvOPVlefxfGrjFGs3EmCeJSt7DwTIwtwF4Q8gGSAknPeQMS2dzql6+nLnBAA0bqrBVkDN3OuHGG6lw+jS/cROnKEfaXdHU7HUIgznXhMHngsiLy/GOi1O6aPPmKT20ho0k9gd6cMS+65zQ156UPfT6rhfbH92eLz2Yc7RqpWbjuZuReDzqjWs0JYCrIuQSFnZOwZYXeJ3nYgdz/xNreeCBRLymYOlZp9fBkcjZZN7WGzq8j4xMRNqS+fHAV3geuA5MIRo65GDNnk7BMhlGILDWhukMwEGO7A2DF+7vha/fY/zSyMv3zaD3/fBmJ9hMM+5iJkeJw0k4bqz87OrObScmYJBK/PG376HzQTD51AJqlBMiXfD+b6qqNCSmCxczWSzwwQdqzTAmJsQO8+cHLAyXJ4Xayw5i8OX6EIw2qDMUrMGNkbee2Monaz/h+83fk+nODNoupZpEz5unfK7XC1tPr2F/ysEg1Ua3z81n8Z9d8H0FMGqU+qLkJCwMunWD+oXQWUijKQKuihl6y5ZQtiyYMlL4t3Es9R50kWwjOGx8sr7qpmN0IaMToM5ilRVyFqMHaTsOjWfC5vvzvJ7Pb2TN3vZ0qLcme9AJno0mfqIfu2hAY7aTiY2A1cwGc6HaWshavJQGpZ3+elfYtGkYzozAvEo3YazlOvZQl3rspfsB6H4AjkfAojoQ7lEyuQD/DNXrwWuGA91zDQavrgoBt90WOiFCSlixxsyvjv8QQzL3MYU4jsIx4A3gmcpQ5hSYy0KDJ6Dxs7mOlzw09yGmb5uORGI2mHnsl8dYNHgRbatlh2U2bFASOgET6DIHQ8pXXlQz7GrV1OPH6NHwxx9Kl2fYMFVjoNGUEK4Khy6++Jy99pcxk8S8OuAMpWa4+A1Y85TS7Db4lDftNwxaTAncz5qJqdoKvJsHoR5wQpdzLt7eJduhuyEpoRIdlqzmFOXJxEYEdky5c8kbzgFr8OzU5IdNtVPwbwn+c1lws49rsGOjHClUJ4FKmXD/5sD9Xl8KL3ZXNwgAfCZwR8GK5/L83M7i8ajknpo1A8f9flXc8/NP/cj0Klte5RW+ZxC3MxeSI6Ha56FXUbOYsX0GM7fPPNdYwom6gd467VYS/pmAIUs4av/+EAKXx1qr1Mxc2Mw2utbsesH3FUSTJrB0acGP02iuEEp9yOXM/32JZ/RTWE4lIYBTEapbUAAJbWHtk+C1gd+q/vWFwfwvwBEoCCUkGFp+TsV7OlOu3BoIoTcuTQ5+85/AvwdIAH6BR18dT4KsRjrR+DGRTjRnyCU25Sgb3CkCJYfb3HkAK8GhHjs2BjCDzvxJfXbTmT84QWzQfk+tgWkzoeMh1XTatHEwfLYJ0qsF7GcjHZHrPfn9MGhQcFrinDnw88+Q6TAABtyE4cDGYL7DHl4eWreGPn2CbMnJlxu+JNMTfBPLcGcQn5i9aN68eYhe26fqY9jXDzPZkrdmg5myYWV5oMUD572uRlMaKdUO/d13wfHvlzC7s/PEuxzKkrPNyZZB4A2hqmfwwe5bsl9L9YTvtkhONFjFmeE9MUcdDD5O+Hl6/UwMrwDPgpwBP/n74SWw5F2S9TRQZyE0nQq7+4E3uCzeZYSVfb/H+9i1iLafnMt9DMOBBDKIJp1onISzluvowzwWtCvHtHubklAx+3312w0rJsK+cUb+ue92wjMrBlzHRgaVOYEM8bXwemHduhwDJ9fw3YcrzjVtyonRCMuHf6eyRkLpxucgZ9/NnAgh8Pqz4/L168PNNwcuyBqNUG7pFF7s+ArXlLmGyhGVGdpyKOtHrFeqjRrNVUapDbmsXefj1ZcFzxAo1FI9lWBpKSlCDMK5cIpEdbD3m7JDIgbwWzOQXd7C8vM4TLjwGgQ2YyozuIMbD+SRy56T2O0wpAeYM1XUxuCm40Ej62uBxafm/naLKvc/FuMH9mC86WksVVdSa+5LRJBBPIHZS57WX7G+z2huNviAFIz1YfhGGP9TVmBICLDZGDuzAal9l/PNgc6Y8eDFxOP8l3W0Yz91gz8JqRZHAdUcYdktmNyTQr+viEhMfXtD8L0piCHNhxCfGB80SzcKI22rBqY2/vCDCmlPmKDqfvr0gbffNlGjxr956cZ/X/hiGk0pp9TN0GftmEXtj2rT/mcThtE2Pmgf6KtXV1ft3gJo+kPg4udZ/Gao+hdhk+bBW2nwzmmY8Bccb6q2GySy+RQMuHmfZ1jr78wpTw1udK8LPA0GWrIhVyhDwqC+EJEEYelgTQeziw017UycA9/NUpWhYd6sVMQsfBY37uY/cPS5Jmx8rgf0GwHhWepXtZfALaNUpZFAiSwa4MsW8P3ZxtAmE3z7LabG9fnsQwfHbHVZxfWcoCJv8QIj+JwIgm9G0dEqsw+A9U+Bz8FDXScSYQ3eVwjokqPz2tdfQ40aakZdt65SSTzL4GsHc33164m0KP12q1G1gpt651TMxsB0SrNZqTcePao0YqZMUefVaDSKUuXQf93zK/fPGszB1IMgICPCxUvd4e1O2fuYg7MUocZqaP0ZmDJBeMDoBJMdbhkJP8zGeaSXEqjym9VC3NcrILO8OtbowVl1JztoSAv+xpBrqu/GTDeWso0mWaEMJbloqvwX2E4E/QUcFvioA/xeC6Zcm2MRMwc+AWlh4AvLgOaT4eH2anGw+wtK9CUXXiN82D7rhccDL7ygfu/WjTL9OtM04iCRwg4WCwOMs7nbMJNw7IRhJ4o0yogzzPsq+VxVJqlbAejdfAEPdplEuMWO1eQkwppORIRk9uxsobMJE1TiyJEjKha/bx8MHqzSDwHMRjML7l/AzAEzebrD07zW7TX2jN5Dr7paF1ejKSj5qhQVQvQGPkZlU38ppXw71/Z/Ag8DXiAZGCqlPHS+c16OStHWE1qzIWlD0Hi0E069q7JFfAKqPA3JucX73BE8+EsLJsfcgN/ihCbT4fQ1MHWekrfNickON7wCnd5TlZazvqPjrnKsIFdD4HCYUHk4/zz0IXZ/4AUtVZfj7vweVNgHsTsDj5Mq5OI2kb/G0K5ImDsRbh4FUcdD7lI7BfZnVeBjNqvy18OH1Yy9Z09o0ACiouDNN8HpZBuNWcYNVCKJfsZfsd7YBb75BipVglmVwZl9ne0JjVi4pScx0T5uH/sJZbLWeqXLzeBKCyH1DL/TjUSyF2AbN4Zt21DqlWPHwt69So74xReVLRqNJiTnqxS94AxdCGEExgE3A42BgUKIxrl22wi0kVJeC8wE3r00ky+Ofaf3hRx3mSA1a8ZolDBvqnLyUS5VcBPugeqbOyI23U/Y9WOh4/tQ5gicrpPV2TkXXhuczKoeNLqh8kZ2t/uNeVGtuJ9v6ckCxseNxP5BOF/5hwY5cwB3YheY8x1MiIev/wBHYMWO++zqRogGF0FYM6DSJkhoH3q7hAHbcrz2eFQeoNerqjwXLlQOtVevc4HyJmznMcZzF7Ow+hxqn1q14KOPVC65MTuzpHHcDp7s+wUPPVrtnDNnwwaoWpVxqYP4lEfYS11e5T/njtm/H5g9W11zwQLYuxc5dSq+lm1IWrw1xJvQaDQX4oIzdCFEB+AVKWWvrNdjAKSUISsuhBAtgf9JKc+rUn05Zujtv2zP2qNrg8bLOiD5XeXMz5JphrkNISUcuu+HRichzQJln8vhwxNbwcQ/wJPLIZszoNc/odXXyoH6TQhAImD+OPh7KDZLJmVsp0k8U40LTrGNTqg/H+4ZkPc+WZ2KZFZcPABXJPwyDo61hOFtVfWnyD6urB32fQJlnbCXOrzDM8TTliZs41neoRlbVVXk8uVKPja3SFVOwsNh5UowzoYdWfKrUkKD0dD8TdVw2OdThTrHA58WMojgNuawhBtp1FCyPS0OEhMD9vEjWGDow/96zeeHH9RDg0ajyeaSZuhANeBIjtcJWWN5MQz4NdQGIcQIIUS8ECI+OfkCinsXwZs93sTotwWM2dzw8rJAZw4Q4YFBW2DUX9D4pPJ/UR4V6jhH1Q0Qt0qFWM5i8EDYGZVm6DeoBUizC2l2qYXVvo9BZBJ2d0T+nDmonPfdfcFtyyPbRtm1579QNR2MOcPkfgGpcbDtLsSJxpgmLqdMQr1z5f9DNsHhj5Uz/5traclGJvIQm2jJVO6lPWtYThcV9Ha7oXPn83f6cLlU6OXa1+CuU9BnM9x5Elq8fa57/MEpq3CdCSEpTCYjmIDNBu8/fwpOnQrax4CkvX8VS5fC0KEX/ug0Gk02+XHooTxSSLcjhLgfaAO8F2q7lPJzKWUbKWWb2Njg4pdLpXWV1lQ1RKp1QamKgCLcMDDrCX4/tenLT4ThIJoz/MP4EWM6h3PtI9D5AfishYknV+d6d4P6QfsPs7JRUqDZ94TdeR9suU859MVvwOdr4KsV8M1vkNRclfDnyXmeiNzqScCUKwsnzAP3boVaqbDiK6iYkXWa0zXhq5UwYRN4rURYM3moyWiclfcQkVUEtK2SehoBeJlXyCACH2rAjwk7ETzGODUrb9BAicL07Kli66Hw+7M1w41hEHkNmLKTw196CR5/2I7TFfy1MQCVwjP45hu4+e6oPJsrnKAiLpdqSBJSIVOj0YQkP3noCUBO2bo4IDH3TkKIG4EXgK5Syvy3ry9ERsx8hiRvMv6sdyWB0+HwyC3wxfSytOMvTlMWP0ZchPEFIyiT0JxmYStY9+fjrHBFQrndRFQYjb3hYiUTYnJBjxeJ6PIiD8cL/vFHBUad+I6lztrw931qRt7lTZWjLvyw4H0VYz9nQV73w1zjlnRIrwqRyZR1QboEq1fF0rsdgPE/q93WVYPUMFRF6dd/QkYVkOoNZ7ii+eKPRdDyGpw2lcr4dyW4/R5Y9TW8xRh+on9QbesOGuF68B9Yz95k581TK5ZNm4b+oG22kMMbNsD77wPuTpgI7uIkIyLoOu5euAvACg8+qGb7OboCZWDjbZTei9Go0hNDCoJpNJog8jNDXwfUE0LUFkJYgHuBT4jMsQAAHopJREFUeTl3yIqbTwD6SylPFL6Z+ePH3VPxmAJnwF4jzGsAr5sfJ6Xpr/hbfwll1eKp9IVxOq0yf6y/G4czWgXPTzUk88d5yKNZRS1Z+dyZFpjQuCxtxTpWHusMp+vCrSNUcdD/t3fe4VFVaQP/nSnpBaT30KSFJtJkRRCxoIhKERUFF2x8rl1RUddP3c+2KiqgoqKL6FJdZQVFELCgSFOqIC1A6KEEUiaZ8n5/nEkyLckEEuLE83ue+2TunXPPfc/M5L3nvuctUTkQc1IvTl5xH7GZ51AtdhvYg80OhR0W4q0cnZcMU5fD3Gk0Oa7YPUGXsds0CT77RJuIDiTA7QO9roxKYMwFuiapL247rCuqSuOywi/1YHcyNCKdSwnO+R1j92Cf+BrbtunEiTt2oGfiUcVEBq1YEfLwzJl6op9DPHfwNjnE4Pb+xFy2GFSXLjqHQAETJsCQIeRbYjhJItnE8SLj+BejAJ1/vmHD0CIYDIZgSp2hi4hLKXU3sBDttjhVRDYppZ4BVovIPLSJJQGYrfRj9B4RObsVAY4cQbkdIXN+uw51YMJDr2iPFEu+1qf53nSLyqVtv8dawKzZcLSVtml/tAjubwKxRc/8jpXjIL8OEAP11kLSXm+5IB9seeT1epNXNi/mnrzpuHYM0HU5caPvn6HqxOH1c4+CDTdxaOe53N31Zhb03EGOiqLr1jp8unA3l4zUi7iA9jdPToebroTJG+FEinewcdrd0lcktz6vQWYunVjHV1xR+F5sLIy61c7AQbp4hN2uTemX9WzCTFs80UEJVAgK5z92TKdZePfdojTFG2mPCzs2XFjx6GFmZ2sPm4JCoNHRMG0aB+6fwI199rMppymZrniU0nJNnlxq5gCDweBDWIFFIrJARM4VkeYi8g/vsae8yhwRuURE6ohIJ+92VpW5LFmKp2EjBm914pfe3GPRRTyrp+nZsy2/SKdG5egw/qg8sOdCrY1wa2+w5ukG+Ymw8FX/C229Wit7gPjDICG0jcWD55ydPNFP4Rp6IwwdDh2mQeepITMDhuiAvdndmP3TKrJzGiFRDla2203qWEhPInQh6C6+ub/FfxEXcFqh7RGw4qERe4mx5JGcJMTY3QxK3Q7HjrJkibZ8nDzp9WRckch4SwhHprg4v9XKrCxd1/O113Sx7QIZZjCcBE4R5TW92JwObcb55z+DumzS+Rxmbkpl5Nh4OnSAQYPgm290lSiDwRA+EV+CLj3NRVLzmiR5MjmYAN1ug2MqkezFE2HTMGiyTC9sBq40hsJjgXUj4IsputK9PRvGJxS9/+5PsM8bchl7DB5oEJwywBmrZ/9xR/H6MhYp4f9MhY3DwV18xaNClBNqbIGkg5CyBLq/idWWHbrM3KbBMHtO0X6b2XD9sMLd5Fw44VOPOcNWl20JnWnq/J06ngMk5B4mh2Bf+eQEFycsNbQbosOhXRsvukgX8/Qumk6cCOPGQY7PPaQRe9hCa+LIDeqTFi10DTuDwXBaVOkSdOP7r2SKRyuOut7C8u1iFrAz93w9m7Z6wBqGMgdtxmj/b6i+C/61jMLV1QJ6TIB572u/9Nxz4LvxcOELhQUpcEWBckO8jzveyYaw9SqdNqDPU5BVH3ZfqE0/+ckU69YodshIhYz2sKcXbL0a95gQdTLz4yGtr/8x5X+Tzozxv6/UdB2k5gntWSroFLyhyHbY4OhemDNH+5RfeCH06uXnnbJokb8yB3BjRRXnzWMJ66HQYDCcBhGt0H/7DXbvtWDx8dv4wd6BnY7zikwju3sXc3Yx2JxQ7xdo9rU2xUCRNkydCavuhD0X6QPfPwEHz4Pur0P8Iai9ochJXIBfb4Ydl8OOy/QN4KvXoeMH2MZ0QGU2w5lXHeZ9AK5YQit27zFXHBw4H9K7Y63/c9Es3RUFOTVhnU/ub7s3v4svx5sxlT6MZmrQFdJIQeHRqXwDaN0anZWrBIfwlBQ9WfepQMd+GrDD0pJ2shHl+wQYG6urABkMhgohoqdLx47BuqiuONCBMNnEMlT9W8+GW/8HLvpfaDcTTtUr0f07iKgs6P8w9HkS9nYHhzeeXQHOBPyU77YBMH2hjig94PMUJFZo+xkMvBMeaAidPtTnrRtFq5WX0TZpEfZ2s+C+pvpGoEqxr3vsMHsmXfdB6yPQ6AR031wf9d634LbqxV17ti6Pd+58n/OssOglnuTZkN0uow/RhPYyLbWU5tq1jE17hCiPv2nFZoOHG8+CGjUhIUEfiI+H7t3h3ntL6dRgMJwuET1D79xJeDb3IaLI5wcuoD+LcEgOjE2FxP1aMYvSJogwAjYLUUCdjdoFcMZcSLsEuk6CSx/WUaKhyE+EDcOg4Up987C4dUrcAq78H9hzIRxrwW9bxxN9xWScViDhsM6WOP8t2Hi9NvNIqBp5oOw5ZCx5hx1pY0jmBJfxBp/Sg9kM5bGLU8htOhMarSw6waNg0Yvw22AOILixaI8TH2pwlCicQbWQbLZSit3Png2jRtHK4WCOZwOj+JBslYA7Ko5OnRXvzWmNOme3Lmu0b59W5n/5S7HBRAaD4cyJ7EXRWbNw3vxXPPlOanOQk1SHq0dDh+nao+VMEfTM+PUdujxc/4chaT/M/dg7Uw9xwiUPQ7e3tBeNLy47fD8evv072HKwPxavFbov+bFwpDW8uxbt5ujTwJ6FavEF8tvwwkNxZHMz03ibsXxe9zyuHXoSSTio/ektTu2ls+ZOABqyl12WxnzeChY3gwanYNTmKGplQAP2c5Tq+D6wxcXB+vXQvHmIYbpcULu2r1sLHhS/21NJvHUIDd55KowP12AwnA5Vd1F04kTs+dk8xEuctEfB1ddD6qyyzcZLQqEVY5+n9WLoTw/BPS2g60T4cRwhfcpPNAtalATA4tJPDAi1zllORihjV1Qu1FsHljzwRGEjH5slB5dEU8+ynfTf/JN35RDPx9zEyzzM1QfXctmb8/m6Xm08MSdhXzfI1zedGHL4u+0Reo2CzbUgK1pHoT5/sfB5Rn++abiKq968jBOZRWuWH3xQjDIH+P33oAKjFoTWzg2w1AGcpkJftw6+/FLfTYYOhXr1Tq8fg+FPSkTb0PMyTrKFVrzBPTCm+5kp8+IeVBTQ0ptrLLum3u//GIzqoz1VAtl+RejOXHGwdSBYHXTo+GDx1xMFVicJnGI5vZjtGUGatCAhLypo4bIza9lNCnHkooAFXMknB17GtutCb14YoT77eJ/RnDx/Bhtqa2UOOqVwDk5ubLyK1If7s3uPYskSHSl6+DBcd10Jn1W1av6roL7UqFHCicWNWXQVjJ494ckntR9k8+Ywd27Z+zIY/sREtEJfkjCIJ3gGZ91NUHvTmc3MC3zGQyHeNy3uorb1V0PH6cFtTzSF5eO0L7rHW480Px62DoDYDLirIz913UDP3dbg6wlwqAN9O3rYndCebqzmKubTgP105FcsFEVNWXDzJVdwDsf97OJ94mdxyB7HCaohWNhHQ25kBp900NWQAnG4HKw/tB6LBbp2LT3ZIgD160O3bkURnwXEx8MDD5RycgiWLdOPBLm5RTnac3Phllvg1KlSTzcYDJqIVeiffw4/r3Ixl6GQ8u2ZdxgyYsfL4XaA0u6FR70FlKNyoEXILMGw7GmY9g2suQN+uRVmztGLqTcMhprbyLEp1u67QyfWytfuldFOSMqDXw/YWPLfHM7J3efX5Xj+jxifpcteLCfWJ3BnYXNoeh80uR/qjXNx5+CTnPJR4NGholoBt8fNfz+L5rnndOh/2Esqs2dDhw7aPJKcrIOO7rvv9MI7p0/XaQECsdl0YQ2DwRAWEWtDf3rwejK4Te8c7HhmnQl6Fp4fC9EB0Y0uO6wfoV9b8iCrDtTYjgXw2E9pd8FQXinpPfRWgDMOWi7Sr90xOE625ryJ0xnR8VLWNNAFNsasheq5G9g98kkaB/SYyiYWcwn38Aa/0Jk6HMSONvmsrwPXXe9ff/Q/3uIdC70PEXdmtmRdyl6ynUWKU6HIPVKPF59vQ26OnmB366bN2MXl5Sqkdm1YvRo2boQDB3QF6dMxt5REJS3YGwyRSkTO0MeNg03uVqTTBFCQdrH2FT/d//8Cc8uJZjpYpwC3FbLrwmbvYmR+MuzsB6CNHOcuhBuvJKwLZ/qUpxdFzKareDrvNe5f6Wb6f2D891AnG5Qnn3pff4hyB1ez7skKVtENF3Zmc31hitp/XgCOgFtznh2+awK7qgHx8dx04/Nc1+Y6Ym2xxNnjSIxKROXWRD75nJxshYjOy/LDD7qsZ9ikpkL//memzEeM0HeTQNxunZvdYDCERcQp9EOH4NVXBCfR+M1h31qnZ8/ebLRlxhMLC1/RUZd5idoGvnkIvLvSG8mJvt6PD8PvRdkKafG19nkvCeWCBqvAkQSOJKJnTmdA9hquZH5wUwR7iFziofiGfuQQy5YaOg1NINFu2FMrCh57DMuga5h27TRW376aVy99lf/rOo2YyelwpJ3fOfn5On9Wr15nsbhEnz5w6606ktRm0+ab2FiYNs3UoDMYykDE+aG/9x7cc4eDXE9M6AY1N8Et/SA+Izi1bUk4Y2DiVv+ZdHEFKpp9DbdcVrS/fjj8973g2qOFfUB8w68ZaJ9FtT2pDHbPpx/fhFv6olg20ZabmUZS/9v5ofuvuG3+QUMx2Nh7x1Zq1m0WdO7WrdClS2jTNeiF0cGD4eOPwxSmPFi3DhYs0LN147ZoMISkyvmhKwmsueNDRjuY8isMvA1aLNAJt6BkLem2wK6LIbMRYanU7Nr++x1m6PS8S57VXi4xxyCrrjefjO4rO/1SpjMgKFLTl7IocwHaspleLOf9FTNwn9cdLJmF443Lh9uizg+pzEGH9deqVbxCz8vTObk+/LDImeXoUfjkE9i7V8/gr7yy+Ep1xXHqlO4vJtT9uGNHvRkMhtMi4kwuAweCQ0rxq8uqC//+L/wjD146Aqvu8roeBlBgntl2FcyZgc3izYVeSIhzrI7Q3i2tvoC7OsMjNeGCV70pcovOb8C+EpV5MVcrFgFOkcDr3Mvnp8Zy9ZQnaLSpO0nZdlpmwCtLo3it7qiQ5zocuvJby5YlL3663bB4sY7YT0jQN4AHH4SXX9Zm7x49gjMtFsfatdC5M5xzjnaKGTJE5+IxGAzlR8SZXPbuhcaNPZT5XlRvDQwbAgkHdfSnWGHL1bD4RT2r1glYQpxY8Pn4OKpfcQ90/kAnwyp4q4D8OJiyBjKKEqFEkce73MYtfFQ2mUsgi3gGMo/G7OV9RmMjwLyUmAh79uggIN/zsuCCC2DnTj07t1qLqgwF/hSUKtnRJCYGxo8vfRF1/35dfzorq+iY3Q7t22tHGZPexWAInyplclm8GE4rguhAF3h9J9TcovczWgf1Y1EuPBL4kYSYsX/5Bvx2nU5T2+xriMvQ+cvzE+CzD/yUOQhv8LeQyrwsJhYPSpfKEzc5xPMp17GMvoBiC62Zy2CS0auYjqgkan09N0iZA7z5JmzfXlSX2deZJlCBl3avdzi0C/mDD2pTSq1aoZXzO+8EZQrA6dR2/FWrtKukwWA4cyJOoTsC0wKWCQUZbYp912Jx43H7fiTFPQkoXVSioLBEwgGdWfFYC50YqxChL0u4g3d9jhQp8XCVeQ4xvM8YGjSJ4mBaLnMYwlKvMgdYSXcas4dUNmJB6DC0PdN6FMnhdOqI+smTiwIv27KJFNL4lU7sp4GW7TQe1g4ehOrV9euaNeGtt7RZzJfNm7VNPhCLRT8pGIVuMJQPEWdD79ev4vp2DRgLCfu1KcXq0IoaIO4I1NrsrTcagqx6cPTcAGUOceQwibv9jpXVTu7CyhZas9zSm2rqBNnEcZC6QT0JFjbQgd+iOnL/2DxtoPZq6Ntugzfe0Mq8Gsf5gV6spBsfcxPbac4UxqBKse+HwmLRZpu8PL3t2wfDh8PKlf7tevbUAaWBuFw62NRgMJQPEWdDJzOT2tWyOUL9Mp5YkoFDtGfKozV1/pUTTXVmxB39dXm5ll+C27t6+PVLhSlpg/v1oOMvhS6s4U3+Rg9+LqOcwVID5GMnGidObDixcydv8REj/domcIof299B+61ztTJv1IjjL79H/xtqcl/+i7RlM9U5Tn32EU2RDSSLOB7lxaCbT0nYbNr27gm4DygF11wDn35adOzECW1DP3q0yMQTGwuXXALz5pXl0zAYDCXZ0CNPoa9bR9NHniJt0VwIsncHIgF/i3kgUS646XJo8U3RMXcUZDaBxD1g95mZ58fBrDmw/QoSEqBdO5Bjx9i9LZ9O/MpzPMH5rCn7uMpINnHU5SBZ6MAbux2+je5PD+f3KB/7htseTb5TYScfG55ib2vbaMG5BBdvtlj8lbbNBo0bwyOP6O3kyeC+UlNhwwb/Y+np8OijOptjXBzcfjs8/ngYKQYMBoMfVWpRdFNCDofPnwc1roGvJsDxFIoKQYRQVQ1/hIufhMUvwOH2WBA8rlhi7A5EFEoJ+Z2m4mm6xO+02Ggrrhq7cUpAityoHOr0uo9+7moMe6o13S6rzm9NR3AxxSTqqiDssTZua/Qdb+68EpsN/nbFdnp8udxPmQNYnHnE+uwX94ySjL9mVkq7GD79tJ5xT5+uXRR799Zmr5MndS6uQGw27aMeSMOGug+DwVBxRJxC/zEtF48nClrN1xvAlgEwYx4EFjq2Z0O/J6DpMri9O/bMhnxfO5Hm1Q/x+ZpryHIk0KfNUv4yeQpZJ5pjSdpPXLyVKIudf/T7B48sfBCnKzjneULS73y8+y/wYDUeXbiWQXnFlKWrQKLs8OpbsbzS1+tZsmgXLIkCh39ysbBs9lYrrouvoE06bNmiPR7vuUcrc6v3I330Uf9TkpN1ptzXXy8KTlJKz77HjTvDwRkMhtMi4hS6Y+d5OKwBppPWC6DrW/DrqKLScPYsaLYIUpbp/fw4rq2WS2rtY8TH5HBr7w/IzY9l/OznyN7Xnfc6bKH7wC043Ll0qtsJt8fNI18F5/a2uaFvGtoOkZlJl8+eYAbX04F1xBNmlE0ABQYhB1G4sRLvLVhRInY79O5d5CbYvn2ZXIAKTS8xMZCYSP33n2VzI71QabWG5xv+3HPQrJkONMrI0LP355+Hpk3DFsNgMJQjEeflcmBXNfj2KXAGGF8H/A2GDoPWc6H2eqi+C/p6S6E5kuCnB1k7LY35B1/hm02XMGfVMK6esJB3lt3P1KmK0WOspNZpx/n1z8dmsRFti+bFXv9LnM8E3eaGhHx44jvvAbebvvlf8y63sY2WZKFzubiwkocdsZaQY90HURYm2u4ljjxasY0s4kvOL5aQoHOe+Mbd160Lo0b5u5NYLNpIHRhnHxOD6tlT204ef1z7FTZqpMdoCz/QRykYPVrP6jMy9EJoq1bhnWswGCoAEamUrUuXLnI6PPmkCIjQdqbwlEV4Gv/t8TihwQrdBhGUS8Aj8fEiOTm6j127RF5/XWTSJJF9+0q4mMcjCy5vLr1HIc3uQUYPRNKSCzrWW0atVhIbKxJNrozkA5nNdTJR3S139NogcvCgyAMPiDRpImK3i9hsfucWbB6LRR5r+5nEx+tDdTgg36te4g7RVpQSGTeuUMS8PJFvvxX58UcRV75bZMIEkaZNRapXFxk2TGTzZv03OlokOVkkJkZk7FgRt/u0Pn+DwVC5AKulGL0acQr9p59E4uK8+q3lfK3AH4sXHo8VxscIFz0tIGK1FunAuDiRt98+jYstXSqFWraYzT38BhkyRCQ2ViQxUSQhQaR9e5FDh3z6+fRTH6FDb56kJJn9zzS5/HKRIUNEfrvv7dDn2GwiTz0lIiLz52sdnZSkr12njsjPPxczln37RJYvFzly5DQ+CIPB8EehJIUecW6LIjBypH68z84GYo5jafcZYsshes8VxOU14+9/1/lDvvoKGjSAhx6Cvn1PQ8gxY2Dq1JJDKBs1gj172LpVJ6BKSdFJq/zMFm3aaLtESdjtcMcdOjYfdAhmSkpwiGVsLKxZQ3piG1q1Ck6OlZysA3xC1YswGAyRzxm7LSqlLgdeR7uRvCciLwS8Hw1MA7oAR4HrRSTtTIQuXhadKXDYMO0GZ7VWZ+TIW+nZE44f1/WLC0zLL7xQcl/lwpEjgLYdF2s/TksrvR+nE372BiGJwKRJ/g7gSml7+DPPQJs2fPS8XsAMxO3WwTo33FCmURgMhipAqQpdKWUFJgH9gXRglVJqnohs9mk2GjguIi2UUsOBF4HrK0JgLRNcdZXefCn34jYjRsCMGcUnDQddS7M0zj0X1q8vuY3VqmfyoKtKvPaaf0YrqxUuvlg/bqDvI/nBHpW4XDoi02Aw/PkIx8ulG7BdRHaKSD4wAxgU0GYQ8C/v6zlAP6WqQFLUiy6Cv/5VmzksAR9VgdP1K6+U3s/zz+s+SiI6WodeArz0UvBNxOWCJUsKQzMvu0w7uwSilNb7BoPhz0c4Cr0BsNdnP917LGQbEXEBmUBQ1WCl1O1KqdVKqdVHvKaKPzRK6axWK1Zop+t779XO1o0b65SCy5drg3lpDBgAs2bpGbjdrm3jffpod0KbTdtqvvhC5xEA7QMYCotFJ0ZB12W+4AJ/W3l8PNx0E7Rte0ajNhgMEUo4NvTiSl+WtQ0iMgWYAnpRNIxr/zHo0OHM0wKGshE5nXrRM3Cq3a+frvUWmPkqKUnH0KN1+/z52jozbZqe4I8ZA9dee2ZiGgyGyCUchZ4ONPLZbwgElrkvaJOulLIByYApMFYadntRwU5fnn1Wa+usLK30ldImm8mT/Uw/Npv2+Bk5MrgLg8Hw5yMck8sqoKVSqqlSKgoYDgQmPZ0HhblchwBLpLL8IasCKSl6EXXsWOjUCQYPhqVL4brrKlsyg8HwB6bUGbqIuJRSdwML0W6LU0Vkk1LqGbSD+zzgfeAjpdR29Mx8eEUK/aegYUOYMKGypTAYDBFEWH7oIrIAWBBw7Cmf1w5gaPmKZjAYDIayEHHJuQwGg8EQGqPQDQaDoYpgFLrBYDBUEYxCNxgMhiqCUegGg8FQRTAK3WAwGKoIRqEbDAZDFaHSClwopY4Au8uhq5pAMdmsqiRmvFWXP9NYwYz3dGkiIrVCvVFpCr28UEqtLq56R1XEjLfq8mcaK5jxVgTG5GIwGAxVBKPQDQaDoYpQFRT6lMoW4Cxjxlt1+TONFcx4y52It6EbDAaDQVMVZugGg8FgwCh0g8FgqDJEjEJXSl2ulNqqlNqulHo0xPvRSqmZ3vd/VkqlnH0py4cwxvqAUmqzUmq9UuobpVSTypCzvChtvD7thiilRCkV0a5u4YxXKTXM+x1vUkp9crZlLE/C+D03VkotVUr94v1ND6gMOcsDpdRUpdRhpdTGYt5XSqk3vJ/FeqXUeeUqgIj84Td0paQdQDMgClgHtA1oMxZ42/t6ODCzsuWuwLH2BeK8r++K1LGGO15vu0TgO2AFcH5ly13B329L4Begune/dmXLXcHjnQLc5X3dFkirbLnPYLy9gfOAjcW8PwD4ElBAD+Dn8rx+pMzQuwHbRWSniOQDM4BBAW0GAf/yvp4D9FNKqbMoY3lR6lhFZKmI5Hh3V6ALd0cq4Xy3AM8CLwGOsylcBRDOeG8DJonIcQAROXyWZSxPwhmvAEne18kEF6GPGETkO3QZzuIYBEwTzQqgmlKqXnldP1IUegNgr89+uvdYyDYi4gIygRpnRbryJZyx+jIafcePVEodr1KqM9BIRL44m4JVEOF8v+cC5yqlliulViilLj9r0pU/4Yz3aWCEUiodXeryb2dHtEqhrP/fZSKsmqJ/AELNtAP9LcNpEwmEPQ6l1AjgfOCiCpWoYilxvEopC/AaMOpsCVTBhPP92tBmlz7op6/vlVKpInKigmWrCMIZ7w3AhyLyilKqJ7rgfKqIeCpevLNOheqpSJmhpwONfPYbEvxYVthGKWVDP7qV9OjzRyWcsaKUugQYD1wtInlnSbaKoLTxJgKpwDKlVBra7jgvghdGw/0tfy4iThHZBWxFK/hIJJzxjgZmAYjIT0AMOpFVVSSs/+/TJVIU+iqgpVKqqVIqCr3oOS+gzTxgpPf1EGCJeFchIoxSx+o1QbyDVuaRbF+FUsYrIpkiUlNEUkQkBb1mcLWIrK4ccc+YcH7Ln6EXvlFK1USbYHaeVSnLj3DGuwfoB6CUaoNW6EfOqpRnj3nALV5vlx5ApogcKLfeK3tVuAyrxwOA39Er5uO9x55B/3OD/hHMBrYDK4FmlS1zBY51MXAI+NW7zatsmStyvAFtlxHBXi5hfr8KeBXYDGwAhle2zBU83rbAcrQHzK/ApZUt8xmM9d/AAcCJno2PBu4E7vT5bid5P4sN5f1bNqH/BoPBUEWIFJOLwWAwGErBKHSDwWCoIhiFbjAYDFUEo9ANBoOhimAUusFgMFQRjEI3GAyGKoJR6AaDwVBF+H9hCzixx6tQfgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# DATA VISUALIZATION\n",
    "single_feature_vectors = [[] for _ in range(len(x[0]))]\n",
    "color_map = {\"Baroque\":\"red\", \"Classical\":\"green\",\n",
    "            \"Romantic\":\"blue\", \"Modern\":\"orange\"}\n",
    "colors = []\n",
    "for k, data_pt in enumerate(agg_x):\n",
    "    colors.append(color_map[agg_y[k]])\n",
    "    for i in range(len(data_pt)):\n",
    "        single_feature_vectors[i].append(data_pt[i])\n",
    "for a in range(2):\n",
    "    for b in range(2):\n",
    "        if a != b:\n",
    "            print(KEYWORDS[a], \"vs.\", KEYWORDS[b])\n",
    "            plt.scatter(single_feature_vectors[a], single_feature_vectors[b], c=colors)\n",
    "            plt.show()\n",
    "            print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, x_test, y_train, y_test = train_test_split(agg_x, agg_y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adaboost\n",
    "AdaBoost is a boosting algorithm that iterates on the weights with multiple decision stumps to boost performance of these weak classifiers. The weights are first initialized as 1/n, with n being the size of the training set. These decision stumps are “weak” because the value of each weight is a threshold for each feature, dividing the dataset into four subsets based on the threshold value. In each iteration, the weight is updated according to the error measured by an exponential loss function. \n",
    "\n",
    "We chose Adaboost as our preliminary model because features we are using are simple and straightforward relative to the complex nature of the audio data. In order to reconcile the simplicity of the features with the complexity of task, we chose ensemble models that use weak classifiers to model a complex system. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train accuracy: 0.6400580551523948\n",
      "Test accuracy: 0.5884057971014492\n",
      "[0.02 0.14 0.1  0.1  0.08 0.1  0.14 0.1  0.1  0.12]\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=50, random_state=0, )\n",
    "clf.fit(x_train, y_train)\n",
    "print(\"Train accuracy:\", clf.score(x_train, y_train))\n",
    "print(\"Test accuracy:\", clf.score(x_test, y_test))\n",
    "print(clf.feature_importances_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{('Modern', 'Baroque'): 3, ('Baroque', 'Romantic'): 31, ('Romantic', 'Romantic'): 123, ('Baroque', 'Baroque'): 61, ('Classical', 'Romantic'): 35, ('Romantic', 'Baroque'): 16, ('Classical', 'Classical'): 16, ('Modern', 'Romantic'): 13, ('Classical', 'Baroque'): 15, ('Baroque', 'Classical'): 9, ('Romantic', 'Modern'): 4, ('Romantic', 'Classical'): 9, ('Modern', 'Classical'): 4, ('Modern', 'Modern'): 3, ('Classical', 'Modern'): 1, ('Baroque', 'Modern'): 2}\n"
     ]
    }
   ],
   "source": [
    "matrix = {}\n",
    "\n",
    "for i, x in enumerate(x_test):\n",
    "    g = clf.predict([x])[0]\n",
    "    era = y_test[i]\n",
    "    if (era, g) in matrix: matrix[(era,g)] += 1\n",
    "    else: matrix[(era,g)] = 1\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest\n",
    "Random Forest is an ensemble model that combines multiple simple decisions trees for added complexity. One key strength of Random Forest is the robustness against possible overfitting: each decision tree is instantiated randomly, it is more likely to capture the variation in the data. Another difference between Random Forest and Adaboost is that while the number of estimator parameter specifies the number of iteration in Adaboost, the number of estimator is a parameter for the number of decision trees to be constructed in a Random Forest classifier model. Instead of iterating each weight n times, Random Forest takes an average over n decision tree at the end. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train accuracy: 0.6008708272859217\n",
      "Test accuracy: 0.5594202898550724\n",
      "[0.09432571 0.12601328 0.00848939 0.00476838 0.10975293 0.34168554\n",
      " 0.06096997 0.03538372 0.01437037 0.20424071]\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=50, max_depth=2, random_state=0)\n",
    "clf.fit(x_train, y_train)\n",
    "print(\"Train accuracy:\", clf.score(x_train, y_train))\n",
    "print(\"Test accuracy:\", clf.score(x_test, y_test))\n",
    "print(clf.feature_importances_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparison of Models\n",
    "Both models were trained with the number of estimator parameter = 50, and performed moderately well with an accuracy rate of ~0.60, which is 0.15 over the threshold value (0.45) and is comparable to the current level of success with genre classification. Nevertheless, an improvement in the performance is desired 60\\% is barely over a majority value. Interestingly, the accuracy of models have consistently decreased from our preliminary results as we increased our data by one order of magnitude (100 -> +1700 data points). This suggests the failure of simple models in processing larger variations in a bigger data set and the necessity of more complex techniques, such as recurrent neural networks. Furthermore, while we expected Random Forest to perform better because it is more robust against over-fitting, Adaboost performed marginally better than Random Forest in both training and test set.\n",
    "\n",
    "An examination of the weight assignment yields more insights into the performance of the two models. First, we observe that the weight assignment for the Adaboost is more uniform across the ten features compared to Random Forest. In fact, the weights for the Adaboost are all around 0.1 for every feature except the mean of the spectral centroid. This is consistent with our understanding of the algorithms because the Adaboost initializes the weight for each feature with 1/n = 1/10 = 0.1 and then updates the weights after each iteration. With our low number of iterations (n=50), it is understandable that the feature weights do not deviate strongly from the initial values. However, we surprisingly found that the Adaboost performs worse with a larger estimator, which suggests the inherent limitation in the algorithm to process complex data. Since the Random Forest merges observations of randomly initialized decision trees, it is more precise than the Adaboost in that it weighs stronger features more heavily. \n",
    "\n",
    "Two notable features for the Random Forest model are the standard deviation of the spectral rolloff (=0.35, over 1/3) and the standard deviation of tonal centroid (=.21). We've seen the importance of the former feature consistently in our previous experiments. For each audio segment, (i.e. for each audio frame), spectral rolloff is the frequency at which 85\\% of the energy lies below the frequency, so the standard deviation of this feature reflects how the energy of a piece changes over time. Intuitively, this comes close to human \"feeling\" of a piece, which makes it a good feature. To illustrate, we expect the spectral energy to be more concentrated in the midrange of piano for a Baroque piece, in contrast with a modern piece, whose spectral energy is more likely to be widely dispersed throughout the possible frequency range. Similarly, the standard deviation of tonal centroid measures how harmonious the chords are in a piece, which is understandably a distinguishing factor for pieces across different eras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{('Modern', 'Baroque'): 10, ('Baroque', 'Romantic'): 42, ('Romantic', 'Romantic'): 132, ('Baroque', 'Baroque'): 61, ('Classical', 'Romantic'): 36, ('Romantic', 'Baroque'): 20, ('Classical', 'Baroque'): 31, ('Modern', 'Romantic'): 13}\n"
     ]
    }
   ],
   "source": [
    "matrix = {}\n",
    "\n",
    "for i, x in enumerate(x_test):\n",
    "    g = clf.predict([x])[0]\n",
    "    era = y_test[i]\n",
    "    if (era, g) in matrix: matrix[(era,g)] += 1\n",
    "    else: matrix[(era,g)] = 1\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Error Analysis\n",
    "First, we can see that the Adaboost classifier never predicted Classical or Modern on the test dataset, which reveals the limitation of the model based on weak classifiers. This model failed to account for the minority data of the pieces from the Classical and Modern eras and over-fitted to the more abundant data. \n",
    "\n",
    "In contrast, the Random Forest model seems provides a more nuanced classification, and we expect that this model would outperform the Adaboost with a larger scale data. We suspect the lower performance on our test set of the Random Forest to the relatively small size of our data. \n",
    "\n",
    "Since a near majority of the data was from the Romantic era, both models performed most successfully in predicting Romantic pieces. We expect to see a notable increase in the performance, especially in the Baroque, Classical, and Baroque data with more song data and more complex models."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}