setup_feature_training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experimental setup, feature extraction and training\n",
    "This notebook sets up the experiments in the 10-fold cross validation scheme for all parameters to be tested, extracts the features (either pitch distribution or pitch-class distribution) and computes the training models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import itertools\n",
    "import json\n",
    "import numpy as np\n",
    "from morty.extras.foldgenerator import FoldGenerator\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup the cluster\n",
    "\n",
    "**Important:** ipyparallel executes the code in where the engines have started. So you should start the cluster in the folder of this notebook to avoid errativ behaviour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7]\n",
      "importing compute_recording_distributions from dlfm_code.trainer on engine(s)\n",
      "importing train_single from dlfm_code.trainer on engine(s)\n",
      "importing train_multi from dlfm_code.trainer on engine(s)\n"
     ]
    }
   ],
   "source": [
    "# ipyparallel\n",
    "import ipyparallel\n",
    "\n",
    "# get the clients\n",
    "clients = ipyparallel.Client()\n",
    "print(clients.ids)\n",
    "\n",
    "# create a direct view into the engines\n",
    "dview = clients.direct_view()\n",
    "\n",
    "with dview.sync_imports():\n",
    "    from dlfm_code.trainer import compute_recording_distributions\n",
    "    from dlfm_code.trainer import train_single\n",
    "    from dlfm_code.trainer import train_multi \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set the dataset paths and define the parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# paths\n",
    "data_path = os.path.join('.', 'data')\n",
    "dataset_path = os.path.join(data_path, 'otmm_makam_recognition_dataset')\n",
    "\n",
    "# training parameters\n",
    "distribution_types = [\"pd\", \"pcd\"]\n",
    "step_sizes = [7.5, 15.0, 25.0, 50.0, 100.0]\n",
    "kernel_widths = [0, 7.5, 15.0, 25.0, 50.0, 100.0]\n",
    "model_types = ['single', 'multi']\n",
    "\n",
    "# load annotation\n",
    "annotations = json.load(open(os.path.join(dataset_path, 'annotations.json')))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the stratifies folds in 10-fold cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# divide the data into stratified 10-fold\n",
    "cemil_death = 1916  # use Tanburi Cemil Bey's death year for reproducability\n",
    "folds = FoldGenerator.stratified_k_fold(\n",
    "    os.path.join(dataset_path, 'data'), annotations, n_folds=10, random_state=cemil_death)\n",
    "\n",
    "# add index to folds for saving the training model later\n",
    "folds = list(enumerate(folds))\n",
    "\n",
    "json.dump(folds, open(os.path.join(data_path, 'folds.json'), 'w'), indent=4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature extraction\n",
    "Here we compute the two distributions for each recording. The first is a histogram, which will be used to accumulate the \"single data point per mode\" model and the other is a probabilty density function (i.e. the histogram normalized by the sum of the values), which is directly used in the \"multi data point per mode\" model in the next step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# compute the distribution per recording for all combinations\n",
    "fcombs = list(itertools.product(\n",
    "        step_sizes, kernel_widths, distribution_types, annotations, \n",
    "        [dataset_path], [data_path]))\n",
    "# ignore combinations in which kernel_width is three times less than the step_size\n",
    "fcombs = [c for c in fcombs if c[1] == 0 or 3 * c[1] >= c[0]]\n",
    "fcombs = np.array(fcombs).transpose().tolist()\n",
    "\n",
    "feature_result = dview.map_sync(compute_recording_distributions, *fcombs)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "- Trains the \"single data point per mode\" model from the extracted histograms\n",
    "- Trains the \"multi data point per mode\" model from the extracted probability density functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# get all parameter combinations\n",
    "tcombs = list(\n",
    "    itertools.product(step_sizes, kernel_widths, distribution_types, folds, [data_path]))\n",
    "# ignore combinations in which kernel_width is three times less than the step_size\n",
    "tcombs = [c for c in tcombs if c[1] == 0 or 3 * c[1] >= c[0]]\n",
    "tcombs = np.array(tcombs).transpose().tolist()\n",
    "\n",
    "single_result = dview.map_sync(train_single, *tcombs)\n",
    "multi_result = dview.map_sync(train_multi, *tcombs)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}