04_subseqDTW.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_list = list(filter(lambda x: (str(x)[-1] in ['1', '5']), range(1, 201)))\n",
    "test_list = list(filter(lambda x: (str(x)[-1] not in ['1', '5']), range(1, 201)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy.matlib import repmat\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image, ImageFilter, ImageChops\n",
    "import cv2\n",
    "import glob\n",
    "from skimage import filters, measure\n",
    "from skimage.measure import label, regionprops\n",
    "from skimage.color import label2rgb\n",
    "from sklearn.cluster import KMeans\n",
    "import matplotlib.patches as mpatches\n",
    "from scipy.signal import convolve2d\n",
    "from scipy.spatial import KDTree\n",
    "import seaborn as sns\n",
    "import pickle\n",
    "import librosa as lb\n",
    "import time\n",
    "import cProfile\n",
    "import os\n",
    "import os.path\n",
    "import pyximport; pyximport.install()\n",
    "import multiprocessing\n",
    "import math\n",
    "import time\n",
    "import librosa\n",
    "import csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "### system parameters ###\n",
    "dtw_steps = [1,1,1,2,2,1] # dtw\n",
    "dtw_weights = [1,1,2]\n",
    "##########################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadMidiBootlegScore(pkl_file):\n",
    "    with open(pkl_file, 'rb') as f:\n",
    "        d = pickle.load(f)\n",
    "    bscore = d['bscore']\n",
    "    miditimes = d['times']\n",
    "    num_notes = np.array(d['num_notes'])\n",
    "    stafflines = d['stafflines']\n",
    "    return bscore, miditimes, num_notes, stafflines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadSheetBootlegScore(pkl_file):\n",
    "    with open(pkl_file, 'rb') as f:\n",
    "        d = pickle.load(f)\n",
    "    bscore = d['bscore']\n",
    "    events = d['events']\n",
    "    return bscore, events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def costMetric(X,Y):\n",
    "    cost = -1 * np.dot(X,Y)\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalizedCostMetric(Q, R, numQueryNotes, numRefNotes):\n",
    "    cost = -1 * np.matmul(Q.T, R)\n",
    "    query_norm_factor = repmat(numQueryNotes.reshape((-1,1)), 1, R.shape[1])\n",
    "    ref_norm_factor = repmat(numRefNotes.reshape((1,-1)), Q.shape[1], 1)\n",
    "    norm_factor = np.maximum(query_norm_factor, ref_norm_factor) + 1e-8 # avoid divide by 0\n",
    "    norm_cost = cost / norm_factor\n",
    "    return norm_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alignBootlegScores(query, ref, numRefNotes, steps = [1,1,1,2,2,1], weights = [1,1,2], optimized=True):\n",
    "    if optimized: # Cython implementation\n",
    "        # set params\n",
    "        assert len(steps) % 2 == 0, \"The length of steps must be even.\"\n",
    "        dn = np.array(steps[::2], dtype=np.uint32)\n",
    "        dm = np.array(steps[1::2], dtype=np.uint32)\n",
    "        dw = weights\n",
    "        subsequence = True\n",
    "        parameter = {'dn': dn, 'dm': dm, 'dw': dw, 'SubSequence': subsequence}\n",
    "\n",
    "        # Compute cost matrix\n",
    "        #cost = costMetric(query.T, ref)\n",
    "        numQueryNotes = np.sum(query, axis=0)\n",
    "        cost = normalizedCostMetric(query, ref, numQueryNotes, numRefNotes)\n",
    "\n",
    "        # DTW\n",
    "        [D, s] = DTW_Cost_To_AccumCostAndSteps(cost, parameter)\n",
    "        [wp, endCol, endCost] = DTW_GetPath(D, s, parameter)\n",
    "\n",
    "        # Reformat the output\n",
    "        wp = wp.T[::-1]\n",
    "    else: # librosa implementation\n",
    "        steps = np.array(steps).reshape((-1,2))\n",
    "        D, wp = lb.sequence.dtw(query, ref, step_sizes_sigma = steps, weights_mul = weights, subseq = True, metric = costMetric)\n",
    "    return D, wp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "import numpy as np\n",
    "cimport numpy as np\n",
    "cimport cython\n",
    "\n",
    "import sys\n",
    "import time\n",
    "\n",
    "\n",
    "DTYPE_INT32 = np.int32\n",
    "ctypedef np.int32_t DTYPE_INT32_t\n",
    "\n",
    "DTYPE_FLOAT = np.float64\n",
    "ctypedef np.float64_t DTYPE_FLOAT_t\n",
    "\n",
    "cdef DTYPE_FLOAT_t MAX_FLOAT = float('inf')\n",
    "\n",
    "# careful, without bounds checking can mess up memory - also can't use negative indices I think (like x[-1])\n",
    "@cython.boundscheck(False) # turn off bounds-checking for entire function\n",
    "def DTW_Cost_To_AccumCostAndSteps(Cin, parameter):\n",
    "    '''\n",
    "    Inputs\n",
    "        C: The cost Matrix\n",
    "    '''\n",
    "\n",
    "\n",
    "    '''\n",
    "    Section for checking and catching errors in the inputs\n",
    "    '''\n",
    "\n",
    "    cdef np.ndarray[DTYPE_FLOAT_t, ndim=2] C\n",
    "    try:\n",
    "        C = np.array(Cin, dtype=DTYPE_FLOAT)\n",
    "    except TypeError:\n",
    "        print(bcolors.FAIL + \"FAILURE: The type of the cost matrix is wrong - please pass in a 2-d numpy array\" + bcolors.ENDC)\n",
    "        return [-1, -1, -1]\n",
    "    except ValueError:\n",
    "        print(bcolors.FAIL + \"FAILURE: The type of the elements in the cost matrix is wrong - please have each element be a float (perhaps you passed in a matrix of ints?)\" + bcolors.ENDC)\n",
    "        return [-1, -1, -1]\n",
    "\n",
    "    cdef np.ndarray[np.uint32_t, ndim=1] dn\n",
    "    cdef np.ndarray[np.uint32_t, ndim=1] dm\n",
    "    cdef np.ndarray[DTYPE_FLOAT_t, ndim=1] dw\n",
    "    # make sure dn, dm, and dw are setup\n",
    "    # dn loading and exception handling\n",
    "    if ('dn'  in parameter.keys()):\n",
    "        try:\n",
    "\n",
    "            dn = np.array(parameter['dn'], dtype=np.uint32)\n",
    "        except TypeError:\n",
    "            print(bcolors.FAIL + \"FAILURE: The type of dn (row steps) is wrong - please pass in a 1-d numpy array that holds uint32s\" + bcolors.ENDC)\n",
    "            return [-1, -1, -1]\n",
    "        except ValueError:\n",
    "            print(bcolors.FAIL + \"The type of the elements in dn (row steps) is wrong - please have each element be a uint32 (perhaps you passed a long?). You can specify this when making a numpy array like: np.array([1,2,3],dtype=np.uint32)\" + bcolors.ENDC)\n",
    "            return [-1, -1, -1]\n",
    "    else:\n",
    "        dn = np.array([1, 1, 0], dtype=np.uint32)\n",
    "    # dm loading and exception handling\n",
    "    if 'dm'  in parameter.keys():\n",
    "        try:\n",
    "            dm = np.array(parameter['dm'], dtype=np.uint32)\n",
    "        except TypeError:\n",
    "            print(bcolors.FAIL + \"FAILURE: The type of dm (col steps) is wrong - please pass in a 1-d numpy array that holds uint32s\" + bcolors.ENDC)\n",
    "            return [-1, -1, -1]\n",
    "        except ValueError:\n",
    "            print(bcolors.FAIL + \"FAILURE: The type of the elements in dm (col steps) is wrong - please have each element be a uint32 (perhaps you passed a long?). You can specify this when making a numpy array like: np.array([1,2,3],dtype=np.uint32)\" + bcolors.ENDC)\n",
    "            return [-1, -1, -1]\n",
    "    else:\n",
    "        print(bcolors.FAIL + \"dm (col steps) was not passed in (gave default value [1,0,1]) \" + bcolors.ENDC)\n",
    "        dm = np.array([1, 0, 1], dtype=np.uint32)\n",
    "    # dw loading and exception handling\n",
    "    if 'dw'  in parameter.keys():\n",
    "        try:\n",
    "            dw = np.array(parameter['dw'], dtype=DTYPE_FLOAT)\n",
    "        except TypeError:\n",
    "            print(bcolors.FAIL + \"FAILURE: The type of dw (step weights) is wrong - please pass in a 1-d numpy array that holds floats\" + bcolors.ENDC)\n",
    "            return [-1, -1, -1]\n",
    "        except ValueError:\n",
    "            print(bcolors.FAIL + \"FAILURE:The type of the elements in dw (step weights) is wrong - please have each element be a float (perhaps you passed ints or a long?). You can specify this when making a numpy array like: np.array([1,2,3],dtype=np.float64)\" + bcolors.ENDC)\n",
    "            return [-1, -1, -1]\n",
    "    else:\n",
    "        dw = np.array([1, 1, 1], dtype=DTYPE_FLOAT)\n",
    "        print(bcolors.FAIL + \"dw (step weights) was not passed in (gave default value [1,1,1]) \" + bcolors.ENDC)\n",
    "\n",
    "    \n",
    "    '''\n",
    "    Section where types are given to the variables we're going to use \n",
    "    '''\n",
    "    # create matrices to store our results (D and E)\n",
    "    cdef DTYPE_INT32_t numRows = C.shape[0] # only works with np arrays, use np.shape(x) will work on lists? want to force to use np though?\n",
    "    cdef DTYPE_INT32_t numCols = C.shape[1]\n",
    "    cdef DTYPE_INT32_t numDifSteps = np.size(dw)\n",
    "\n",
    "    cdef unsigned int maxRowStep = max(dn)\n",
    "    cdef unsigned int maxColStep = max(dm)\n",
    "\n",
    "    cdef np.ndarray[np.uint32_t, ndim=2] steps = np.zeros((numRows,numCols), dtype=np.uint32)\n",
    "    cdef np.ndarray[DTYPE_FLOAT_t, ndim=2] accumCost = np.ones((maxRowStep + numRows, maxColStep + numCols), dtype=DTYPE_FLOAT) * MAX_FLOAT\n",
    "\n",
    "    cdef DTYPE_FLOAT_t bestCost\n",
    "    cdef DTYPE_INT32_t bestCostIndex\n",
    "    cdef DTYPE_FLOAT_t costForStep\n",
    "    cdef unsigned int row, col\n",
    "    cdef unsigned int stepIndex\n",
    "\n",
    "    '''\n",
    "    The start of the actual algorithm, now that all our variables are set up\n",
    "    '''\n",
    "    # initializing the cost matrix - depends on whether its subsequence DTW\n",
    "    # essentially allow us to hop on the bottom anywhere (so could start partway through one of the signals)\n",
    "    if parameter['SubSequence']:\n",
    "        for col in range(numCols):\n",
    "            accumCost[maxRowStep, col + maxColStep] = C[0, col]\n",
    "    else:\n",
    "        accumCost[maxRowStep, maxColStep] = C[0,0]\n",
    "\n",
    "    # filling the accumulated cost matrix\n",
    "    for row in range(maxRowStep, numRows + maxRowStep, 1):\n",
    "        for col in range(maxColStep, numCols + maxColStep, 1):\n",
    "            bestCost = accumCost[<unsigned int>row, <unsigned int>col] # initialize with what's there - so if is an entry point, then can start low\n",
    "            bestCostIndex = 0\n",
    "            # go through each step, find the best one\n",
    "            for stepIndex in range(numDifSteps):\n",
    "                #costForStep = accumCost[<unsigned int>(row - dn[<unsigned int>(stepIndex)]), <unsigned int>(col - dm[<unsigned int>(stepIndex)])] + dw[<unsigned int>(stepIndex)] * C[<unsigned int>(row - maxRowStep), <unsigned int>(col - maxColStep)]\n",
    "                costForStep = accumCost[<unsigned int>((row - dn[(stepIndex)])), <unsigned int>((col - dm[(stepIndex)]))] + dw[stepIndex] * C[<unsigned int>(row - maxRowStep), <unsigned int>(col - maxColStep)]\n",
    "                if costForStep < bestCost:\n",
    "                    bestCost = costForStep\n",
    "                    bestCostIndex = stepIndex\n",
    "            # save the best cost and best cost index\n",
    "            accumCost[row, col] = bestCost\n",
    "            steps[<unsigned int>(row - maxRowStep), <unsigned int>(col - maxColStep)] = bestCostIndex\n",
    "\n",
    "    # return the accumulated cost along with the matrix of steps taken to achieve that cost\n",
    "    return [accumCost[maxRowStep:, maxColStep:], steps]\n",
    "\n",
    "@cython.boundscheck(False) # turn off bounds-checking for entire function\n",
    "def DTW_GetPath(np.ndarray[DTYPE_FLOAT_t, ndim=2] accumCost, np.ndarray[np.uint32_t, ndim=2] stepsForCost, parameter):\n",
    "    '''\n",
    "\n",
    "    Parameter should have: 'dn', 'dm', 'dw', 'SubSequence'\n",
    "    '''\n",
    "\n",
    "    cdef np.ndarray[unsigned int, ndim=1] dn\n",
    "    cdef np.ndarray[unsigned int, ndim=1] dm\n",
    "    cdef np.uint8_t subseq\n",
    "    # make sure dn, dm, and dw are setup\n",
    "    if ('dn'  in parameter.keys()):\n",
    "        dn = parameter['dn']\n",
    "    else:\n",
    "        dn = np.array([1, 1, 0], dtype=DTYPE_INT32)\n",
    "    if 'dm'  in parameter.keys():\n",
    "        dm = parameter['dm']\n",
    "    else:\n",
    "        dm = np.array([1, 0, 1], dtype=DTYPE_INT32)\n",
    "    if 'SubSequence' in parameter.keys():\n",
    "        subseq = parameter['SubSequence']\n",
    "    else:\n",
    "        subseq = 0\n",
    "\n",
    "    cdef np.uint32_t numRows\n",
    "    cdef np.uint32_t numCols\n",
    "    cdef np.uint32_t curRow\n",
    "    cdef np.uint32_t curCol\n",
    "    cdef np.uint32_t endCol\n",
    "    cdef DTYPE_FLOAT_t endCost\n",
    "\n",
    "    numRows = accumCost.shape[0]\n",
    "    numCols = accumCost.shape[1]\n",
    "\n",
    "    # either start at the far corner (non sub-sequence)\n",
    "    # or start at the lowest cost entry in the last row (sub-sequence)\n",
    "    # where all of the signal along the row has been used, but only a \n",
    "    # sub-sequence of the signal along the columns has to be used\n",
    "    curRow = numRows - 1\n",
    "    if subseq:\n",
    "        curCol = np.argmin(accumCost[numRows - 1, :])\n",
    "    else:\n",
    "        curCol = numCols - 1\n",
    "\n",
    "    endCol = curCol\n",
    "    endCost = accumCost[curRow, curCol]\n",
    "\n",
    "    cdef np.uint32_t curRowStep\n",
    "    cdef np.uint32_t curColStep\n",
    "    cdef np.uint32_t curStepIndex\n",
    "\n",
    "\n",
    "    cdef np.ndarray[np.uint32_t, ndim=2] path = np.zeros((2, numRows + numCols), dtype=np.uint32) # make as large as could need, then chop at the end\n",
    "    path[0, 0] = curRow\n",
    "    path[1, 0] = curCol\n",
    "\n",
    "    cdef np.uint32_t stepsInPath = 1 # starts at one, we add in one before looping\n",
    "    cdef np.uint32_t stepIndex = 0\n",
    "    cdef np.int8_t done = (subseq and curRow == 0) or (curRow == 0 and curCol == 0)\n",
    "    while not done:\n",
    "        if accumCost[curRow, curCol] == MAX_FLOAT:\n",
    "            print('A path is not possible')\n",
    "            break\n",
    "\n",
    "        # you're done if you've made it to the bottom left (non sub-sequence)\n",
    "        # or just the bottom (sub-sequence)\n",
    "        # find the step size\n",
    "        curStepIndex = stepsForCost[curRow, curCol]\n",
    "        curRowStep = dn[curStepIndex]\n",
    "        curColStep = dm[curStepIndex]\n",
    "        # backtrack by 1 step\n",
    "        curRow = curRow - curRowStep\n",
    "        curCol = curCol - curColStep\n",
    "        # add your new location onto the path\n",
    "        path[0, stepsInPath] = curRow\n",
    "        path[1, stepsInPath] = curCol\n",
    "        stepsInPath = stepsInPath + 1\n",
    "        # check to see if you're done\n",
    "        done = (subseq and curRow == 0) or (curRow == 0 and curCol == 0)\n",
    "\n",
    "    # reverse the path (a matrix with two rows) and return it\n",
    "    return [np.fliplr(path[:, 0:stepsInPath]), endCol, endCost]\n",
    "\n",
    "class bcolors:\n",
    "    HEADER = '\\033[95m'\n",
    "    OKBLUE = '\\033[94m'\n",
    "    OKGREEN = '\\033[92m'\n",
    "    WARNING = '\\033[93m'\n",
    "    FAIL = '\\033[91m'\n",
    "    ENDC = '\\033[0m'\n",
    "    BOLD = '\\033[1m'\n",
    "    UNDERLINE = '\\033[4m'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotAlignment(D, wp, seginfo = None):\n",
    "    plt.figure(figsize = (10,10))\n",
    "    plt.imshow(D, origin = 'lower', cmap = 'jet')\n",
    "    plt.plot(wp[:,1], wp[:,0], color='y')\n",
    "    plt.xlabel('Ref')\n",
    "    plt.ylabel('Query')\n",
    "    if seginfo is not None:\n",
    "        #matchSegTime, refSegTimes, refSegCols = seginfo\n",
    "        refSegCols = seginfo\n",
    "        for i, refSegCol in enumerate(refSegCols):            \n",
    "            plt.axvline(refSegCol[0], color = 'm')\n",
    "            plt.axvline(refSegCol[1], color = 'm')\n",
    "        #plt.title('Hyp ({:.1f} s, {:.1f} s), Ref ({:.1f} s, {:.1f} s)'.format(matchSegTime[0], matchSegTime[1], refSegTimes[0][0], refSegTimes[0][1]))\n",
    "    else:\n",
    "        plt.title('Subsequence DTW Alignment')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getPredictedLineInfo(wp):\n",
    "    startEvent = wp[-1, -1]\n",
    "    startPage = events[startEvent][5]\n",
    "    startLine = events[startEvent][2] + 1\n",
    "    endEvent = wp[0, -1]\n",
    "    endPage = events[endEvent][5]\n",
    "    endLine = events[endEvent][2] + 1\n",
    "    return ([startPage, endPage], [startLine, endLine])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getGroundTruthLineInfo(imagefile):\n",
    "    pages = []\n",
    "    lines = []\n",
    "    with open('/home/mshan/ttemp/data/timeAnnot/' + imagefile + '.timeannot.csv', newline='') as csvfile:\n",
    "        reader = csv.reader(csvfile)\n",
    "        for row in reader:\n",
    "            page = row[0].split('L')[0][1:]\n",
    "            pages.append(int(page))\n",
    "            line = row[0].split('L')[1]\n",
    "            lines.append(int(line))\n",
    "    return ([pages[0], pages[-1]], [lines[0], lines[-1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "piece = 154\n",
    "midi_pkl_dir = '/home/mshan/ttemp/data/bscore/0/p{}.pkl'.format(piece)\n",
    "sheet_pkl_dir = '/home/mshan/ttemp/data/bscore_sheet/p{}.pkl'.format(piece)\n",
    "piece_dir = '/home/mshan/ttemp/data/png/p{}'.format(piece)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "bscore_midi, miditimes, _, stafflines = loadMidiBootlegScore(midi_pkl_dir)\n",
    "bscore_sheet, events = loadSheetBootlegScore(sheet_pkl_dir)\n",
    "num_notes = np.asarray([len(event[0]) for event in events])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted page range: [1, 2] Predicted line range: [2, 2]\n",
      "Correct page range: [1, 2] Correct line range: [1, 4]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "D, wp = alignBootlegScores(bscore_midi, bscore_sheet, num_notes, dtw_steps, dtw_weights)\n",
    "matchSegmentPage, matchSegmentLine = getPredictedLineInfo(wp)\n",
    "print(\"Predicted page range: \" + str(matchSegmentPage), \"Predicted line range: \" + str(matchSegmentLine))\n",
    "refSegmentPage, refSegmentLine = getGroundTruthLineInfo('p{}'.format(piece))\n",
    "print(\"Correct page range: \" + str(refSegmentPage), \"Correct line range: \" + str(refSegmentLine))\n",
    "refEvents = []\n",
    "for i, event in enumerate(events):\n",
    "    if event[-1] in refSegmentPage:\n",
    "        refEvents.append(i)\n",
    "plotAlignment(D, wp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Align"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alignPiece(piece, data='data'):\n",
    "    bscore_midi, miditimes, _, stafflines = loadMidiBootlegScore('/home/mshan/ttemp/{}/bscore/p{}.pkl' .format(data, piece))\n",
    "    bscore_sheet, events = loadSheetBootlegScore('/home/mshan/ttemp/{}/bscore_sheet/p{}.pkl'.format(data, piece))\n",
    "    num_notes = np.asarray([len(event[0]) for event in events])\n",
    "    if num_notes.shape[0] != bscore_sheet.shape[1]:\n",
    "        bscore_sheet = bscore_sheet[:, 1:]   \n",
    "    D, wp = alignBootlegScores(bscore_midi, bscore_sheet, num_notes, dtw_steps, dtw_weights)\n",
    "    wp = wp[::-1]\n",
    "    times = [miditime[0] for miditime in miditimes]\n",
    "    midi_frame = [time_point[0] for time_point in wp]\n",
    "    actual_time = [times[k] for k in midi_frame]\n",
    "     \n",
    "    d = {}\n",
    "    d['events'] = events\n",
    "    d['actual_time'] = actual_time\n",
    "    d['wp'] = wp\n",
    "    with open('/home/mshan/ttemp/data/hyp/subseqDTW/{}/p{}.pkl'.format(data, piece), 'wb') as f:\n",
    "        pickle.dump(d, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A path is not possible\n",
      "A path is not possible\n",
      "A path is not possible\n",
      "A path is not possible\n",
      "A path is not possible\n",
      "A path is not possible\n",
      "A path is not possible\n"
     ]
    }
   ],
   "source": [
    "for i in [99, 109, 117, 120, 139, 172, 179, 186]:\n",
    "    for data in ['data', 'data_repeat1', 'data_repeat2', 'data_repeat3', 'data_dsalfine']:\n",
    "        alignPiece(i, data=data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decide the tolerance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "metadata": {},
   "outputs": [],
   "source": [
    "tol = range(0,161,10)\n",
    "res = [0.028613116176562956, 0.6468402900738537, 0.795491114998979, 0.8093670018377619, 0.8113906046759265, 0.8113906046759265, 0.8113906046759265, 0.8113906046759265, 0.8113906046759265, 0.8123558034682697, 0.8123558034682697, 0.8123558034682697, 0.8123558034682697, 0.8083164174063567, 0.796601598125594, 0.7776486651554321\n",
    ", 0.7571104661067255]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'accuracy')"
      ]
     },
     "execution_count": 420,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(tol,res)\n",
    "plt.xlabel('tolerance')\n",
    "plt.ylabel('accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}