コード例 #1
0
ファイル: demos.py プロジェクト: veritasalice/BostonHackDay
def get_data_maxener(pSize=4,
                     keyInv=True,
                     downBeatInv=False,
                     bars=1,
                     partialbar=1,
                     offset=0):
    """
    Util function for something we do all the time
    Remove the empty patterns
    INPUT:
        - pSize        (default: 16)
        - keyInv       (default: True)
        - downBeatInv  (default: False)
        - bars         (default: 2)
    """
    import data_iterator
    import feats_utils as FU
    import numpy as np
    import time
    # start time
    tstart = time.time()
    # get maltab files
    allfiles = FU.get_all_matfiles('.')
    print len(allfiles), ' .mat files found'
    # create and set iterator
    data_iter = data_iterator.DataIterator()
    data_iter.setMatfiles(allfiles)  # set matfiles
    if bars > 0:
        data_iter.useBars(bars)  # a pattern spans 'bars' bars
        if partialbar < 1:
            assert (bars == 1)
            data_iter.usePartialBar(partialbar)
    else:
        data_iter.useBars(0)  # important to set it to zero!
        data_iter.setFeatsize(pSize)  # a pattern is a num. of beats
    if offset > 0:
        data_iter.setOffset(offset)
    data_iter.stopAfterOnePass(True)  # stop after one full iteration
    # get features
    featsNorm = [
        FU.normalize_pattern_maxenergy(p, pSize, keyInv,
                                       downBeatInv).flatten()
        for p in data_iter
    ]
    print 'found ', len(featsNorm), ' patterns before removing empty ones'
    # make it an array
    featsNorm = np.array(featsNorm)
    # remove empyt patterns
    res = [np.sum(r) > 0 for r in featsNorm]
    res2 = np.where(res)
    featsNorm = featsNorm[res2]
    # time?
    print 'all patterns acquired and normalized in ' + str(time.time() -
                                                           tstart) + 'seconds'
    print 'featsNorm.shape = ', featsNorm.shape
    return featsNorm
コード例 #2
0
ファイル: demos.py プロジェクト: jsherrah/BostonHackDay
def encode_one_song(filename,codebook,pSize=8,keyInv=True,
                    downBeatInv=False,bars=2):
    """
    returns: song, encoding, song as MAT, encoding as MAT
    matrices are 'derolled'
    """
    import feats_utils as FU
    import numpy as np
    import data_iterator
    import VQutils

    # create data iterator
    data_iter = data_iterator.DataIterator()
    data_iter.setMatfiles([filename]) # set matfiles
    if bars > 0:
        data_iter.useBars( bars )            # a pattern spans 'bars' bars
    else:
        data_iter.useBars(0)                 # important to set it to zero!
        data_iter.setFeatsize( pSize )       # a pattern is a num. of beats
    data_iter.stopAfterOnePass(True)
    # load data
    featsNorm = [FU.normalize_pattern_maxenergy(p,pSize,keyInv,downBeatInv,retRoll=True) for p in data_iter]
    keyroll = np.array([x[1] for x in featsNorm])
    dbroll = np.array([x[2] for x in featsNorm])
    featsNorm = [x[0].flatten() for x in featsNorm]
    if len(featsNorm) == 0: # empty song
        return [],[],[],[],[]
    featsNorm = np.array(featsNorm)
    res = [np.sum(r) > 0 for r in featsNorm]
    res2 = np.where(res)
    featsNorm = featsNorm[res2]
    keyroll = keyroll[res2]
    dbroll = dbroll[res2]
    assert(dbroll.shape[0] == keyroll.shape[0])
    assert(dbroll.shape[0] == featsNorm.shape[0])
    # find code per pattern
    best_code_per_p, dists, avg_dists = VQutils.find_best_code_per_pattern(featsNorm,codebook)
    best_code_per_p = np.asarray([int(x) for x in best_code_per_p])
    assert best_code_per_p.shape[0] > 0,'empty song, we should have caught that'
    encoding = codebook[best_code_per_p]
    # transform into 2 matrices, with derolling!!!!!!!!!
    assert(featsNorm.shape[0] == encoding.shape[0])
    #featsNormMAT = np.concatenate([x.reshape(12,pSize) for x in featsNorm],axis=1)
    featsNormMAT = np.concatenate([np.roll(np.roll(featsNorm[x].reshape(12,pSize),-keyroll[x],axis=0),-dbroll[x],axis=1) for x in range(featsNorm.shape[0])],axis=1)
    #encodingMAT = np.concatenate([x.reshape(12,pSize) for x in encoding],axis=1)
    encodingMAT = np.concatenate([np.roll(np.roll(encoding[x].reshape(12,pSize),-keyroll[x],axis=0),-dbroll[x],axis=1) for x in range(featsNorm.shape[0])],axis=1)
    # return
    return best_code_per_p,featsNorm,encoding,featsNormMAT,encodingMAT
コード例 #3
0
ファイル: demos.py プロジェクト: jsherrah/BostonHackDay
def get_data_maxener(pSize=4,keyInv=True,downBeatInv=False,bars=1,partialbar=1,offset=0):
    """
    Util function for something we do all the time
    Remove the empty patterns
    INPUT:
        - pSize        (default: 16)
        - keyInv       (default: True)
        - downBeatInv  (default: False)
        - bars         (default: 2)
    """
    import data_iterator
    import feats_utils as FU
    import numpy as np
    import time
    # start time
    tstart = time.time()
    # get maltab files
    allfiles = FU.get_all_matfiles('.')
    print len(allfiles),' .mat files found'
    # create and set iterator
    data_iter = data_iterator.DataIterator()
    data_iter.setMatfiles(allfiles) # set matfiles
    if bars > 0:
        data_iter.useBars( bars )            # a pattern spans 'bars' bars
        if partialbar < 1:
            assert(bars==1)
            data_iter.usePartialBar( partialbar )
    else:
        data_iter.useBars(0)                 # important to set it to zero!
        data_iter.setFeatsize( pSize )       # a pattern is a num. of beats
    if offset > 0:
        data_iter.setOffset(offset)
    data_iter.stopAfterOnePass(True)# stop after one full iteration
    # get features
    featsNorm = [FU.normalize_pattern_maxenergy(p,pSize,keyInv,downBeatInv).flatten() for p in data_iter]
    print 'found ', len(featsNorm),' patterns before removing empty ones'
    # make it an array
    featsNorm = np.array(featsNorm)
    # remove empyt patterns
    res = [np.sum(r) > 0 for r in featsNorm]
    res2 = np.where(res)
    featsNorm = featsNorm[res2]
    # time?
    print 'all patterns acquired and normalized in ' + str(time.time()-tstart) + 'seconds'
    print 'featsNorm.shape = ',featsNorm.shape
    return featsNorm
コード例 #4
0
ファイル: demos.py プロジェクト: veritasalice/BostonHackDay
def test_align_one_song(filename, codebook):
    """
    Experiment on how good can we find the alignment of a song
    Designed for a codebook of pSize=4, bars=1
    If song has non 4 beats patterns, problem

    Return is complex:
      - -1      if could not perform test
      - 0       if test succesful
      - 1-2-3   by how many beats we missed
    """

    import scipy
    import scipy.io
    import numpy as np
    import feats_utils as FU
    import VQutils as VQU

    mat = mat = scipy.io.loadmat(filename)
    btstart = mat['btstart']
    barstart = mat['barstart']
    try:
        btstart = btstart.flatten()
        barstart = barstart.flatten()
        if btstart.shape[0] < 3 or barstart.shape[0] < 3:
            return -1  # can not complete
    except IndexError:
        print 'index error'
        return -1  # can not complete
    except AttributeError:
        return -1  # can not complete
    # find bar start based on beat index
    barstart_idx = [np.where(btstart == x)[0][0] for x in barstart]
    barstart_idx.append(btstart.shape[0])
    # find bar lengths
    barlengths = np.diff(barstart_idx)
    # find not4 elems
    not4 = np.where(barlengths != 4)[0]
    not4 = np.concatenate([[0], not4, [len(barlengths)]])
    # find longest sequence of bars of length 4 beats
    seqs_of_4 = np.diff(not4)
    if len(not4) > 1:
        longest_seq_length = np.max(seqs_of_4) - 1
    else:
        longest_seq_length = not4[0]
    if longest_seq_length < 10:  # why 10? bof....
        #print 'return because longest seq has length:',longest_seq_length
        return -1  # can not complete
    # find best seq pos
    pos1 = not4[np.argmax(seqs_of_4)] + 1
    pos2 = not4[np.argmax(seqs_of_4) + 1]
    # longest sequence should be in range(pos1,pos2)
    # sanity checks
    assert pos2 - pos1 == longest_seq_length
    for k in range(pos1, pos2):
        assert barlengths[k] == 4
    # position in beats
    beat_pos_1 = barstart_idx[pos1]
    beat_pos_2 = beat_pos_1 + 4 * longest_seq_length
    assert beat_pos_2 == btstart.shape[0] or np.where(
        barstart_idx == beat_pos_2)[0].shape[0] > 0
    # load actual beat features
    btchroma = mat['btchroma']
    # try everything: offset 0 to 3
    best_offset = -1
    best_avg_dist = np.inf
    for offset in range(4):
        avg_dist = 0
        for baridx in range(longest_seq_length - 1):
            pos = beat_pos_1 + offset + baridx * 4
            feats = btchroma[:, pos:pos + 4]
            featsNorm = FU.normalize_pattern_maxenergy(feats,
                                                       newsize=4,
                                                       keyinvariant=True,
                                                       downbeatinvariant=False)
            # measure with codebook
            tmp, dists = VQU.encode_oneiter(featsNorm.flatten(), codebook)
            avg_dist += (dists[0] * dists[0]) * 1. / featsNorm.size
        #print 'avg_dist=',avg_dist,'for offset',offset
        if best_avg_dist > avg_dist:
            best_avg_dist = avg_dist
            best_offset = offset
    # done, return offset, which is 0 if fine
    return best_offset
コード例 #5
0
ファイル: demos.py プロジェクト: veritasalice/BostonHackDay
def encode_one_song(filename,
                    codebook,
                    pSize=8,
                    keyInv=True,
                    downBeatInv=False,
                    bars=2):
    """
    returns: song, encoding, song as MAT, encoding as MAT
    matrices are 'derolled'
    """
    import feats_utils as FU
    import numpy as np
    import data_iterator
    import VQutils

    # create data iterator
    data_iter = data_iterator.DataIterator()
    data_iter.setMatfiles([filename])  # set matfiles
    if bars > 0:
        data_iter.useBars(bars)  # a pattern spans 'bars' bars
    else:
        data_iter.useBars(0)  # important to set it to zero!
        data_iter.setFeatsize(pSize)  # a pattern is a num. of beats
    data_iter.stopAfterOnePass(True)
    # load data
    featsNorm = [
        FU.normalize_pattern_maxenergy(p,
                                       pSize,
                                       keyInv,
                                       downBeatInv,
                                       retRoll=True) for p in data_iter
    ]
    keyroll = np.array([x[1] for x in featsNorm])
    dbroll = np.array([x[2] for x in featsNorm])
    featsNorm = [x[0].flatten() for x in featsNorm]
    if len(featsNorm) == 0:  # empty song
        return [], [], [], [], []
    featsNorm = np.array(featsNorm)
    res = [np.sum(r) > 0 for r in featsNorm]
    res2 = np.where(res)
    featsNorm = featsNorm[res2]
    keyroll = keyroll[res2]
    dbroll = dbroll[res2]
    assert (dbroll.shape[0] == keyroll.shape[0])
    assert (dbroll.shape[0] == featsNorm.shape[0])
    # find code per pattern
    best_code_per_p, dists, avg_dists = VQutils.find_best_code_per_pattern(
        featsNorm, codebook)
    best_code_per_p = np.asarray([int(x) for x in best_code_per_p])
    assert best_code_per_p.shape[
        0] > 0, 'empty song, we should have caught that'
    encoding = codebook[best_code_per_p]
    # transform into 2 matrices, with derolling!!!!!!!!!
    assert (featsNorm.shape[0] == encoding.shape[0])
    #featsNormMAT = np.concatenate([x.reshape(12,pSize) for x in featsNorm],axis=1)
    featsNormMAT = np.concatenate([
        np.roll(np.roll(featsNorm[x].reshape(12, pSize), -keyroll[x], axis=0),
                -dbroll[x],
                axis=1) for x in range(featsNorm.shape[0])
    ],
                                  axis=1)
    #encodingMAT = np.concatenate([x.reshape(12,pSize) for x in encoding],axis=1)
    encodingMAT = np.concatenate([
        np.roll(np.roll(encoding[x].reshape(12, pSize), -keyroll[x], axis=0),
                -dbroll[x],
                axis=1) for x in range(featsNorm.shape[0])
    ],
                                 axis=1)
    # return
    return best_code_per_p, featsNorm, encoding, featsNormMAT, encodingMAT
コード例 #6
0
ファイル: demos.py プロジェクト: jsherrah/BostonHackDay
def test_align_one_song(filename,codebook):
    """
    Experiment on how good can we find the alignment of a song
    Designed for a codebook of pSize=4, bars=1
    If song has non 4 beats patterns, problem

    Return is complex:
      - -1      if could not perform test
      - 0       if test succesful
      - 1-2-3   by how many beats we missed
    """

    import scipy
    import scipy.io
    import numpy as np
    import feats_utils as FU
    import VQutils as VQU

    mat = mat = scipy.io.loadmat(filename)
    btstart = mat['btstart']
    barstart = mat['barstart']
    try:
        btstart = btstart.flatten()
        barstart = barstart.flatten()
        if btstart.shape[0] < 3 or barstart.shape[0] < 3:
            return -1 # can not complete
    except IndexError:
        print 'index error'
        return -1 # can not complete
    except AttributeError:
        return -1 # can not complete
    # find bar start based on beat index
    barstart_idx = [np.where(btstart==x)[0][0] for x in barstart]
    barstart_idx.append(btstart.shape[0])
    # find bar lengths
    barlengths = np.diff(barstart_idx)
    # find not4 elems
    not4 = np.where(barlengths!=4)[0]
    not4 = np.concatenate([[0],not4,[len(barlengths)]])
    # find longest sequence of bars of length 4 beats
    seqs_of_4 = np.diff(not4)
    if len(not4)>1:
        longest_seq_length = np.max(seqs_of_4) -1
    else:
        longest_seq_length = not4[0]
    if longest_seq_length < 10: # why 10? bof....
        #print 'return because longest seq has length:',longest_seq_length
        return -1 # can not complete
    # find best seq pos
    pos1 = not4[np.argmax(seqs_of_4)]+1
    pos2 = not4[np.argmax(seqs_of_4)+1]
    # longest sequence should be in range(pos1,pos2)
    # sanity checks
    assert pos2 - pos1 == longest_seq_length
    for k in range(pos1,pos2):
        assert barlengths[k] == 4
    # position in beats
    beat_pos_1 = barstart_idx[pos1]
    beat_pos_2 = beat_pos_1 + 4 * longest_seq_length
    assert beat_pos_2 == btstart.shape[0] or np.where(barstart_idx==beat_pos_2)[0].shape[0]>0
    # load actual beat features
    btchroma = mat['btchroma']
    # try everything: offset 0 to 3
    best_offset = -1
    best_avg_dist = np.inf
    for offset in range(4):
        avg_dist = 0
        for baridx in range(longest_seq_length-1):
            pos = beat_pos_1 + offset + baridx * 4
            feats = btchroma[:,pos:pos+4]
            featsNorm = FU.normalize_pattern_maxenergy(feats,newsize=4,
                                                       keyinvariant=True,
                                                       downbeatinvariant=False)
            # measure with codebook
            tmp,dists = VQU.encode_oneiter(featsNorm.flatten(),codebook)
            avg_dist += (dists[0] * dists[0]) * 1. / featsNorm.size
        #print 'avg_dist=',avg_dist,'for offset',offset
        if best_avg_dist > avg_dist:
            best_avg_dist = avg_dist
            best_offset = offset
    # done, return offset, which is 0 if fine
    return best_offset
コード例 #7
0
    
    # feature from matfile
    mat_feats = features.features_from_matfile(tmpfilemat,pSize=8,usebars=2,
                                               keyInv=True,songKeyInv=False,
                                               positive=False,do_resample=True)
    mat_feats = mat_feats[np.nonzero(np.sum(mat_feats,axis=1))]
    print 'features from matfile computed, shape =',mat_feats.shape

    # features from matfile old school
    import data_iterator
    import feats_utils as FU
    data_iter = data_iterator.DataIterator()
    data_iter.setMatfiles([tmpfilemat])
    data_iter.useBars(2)
    data_iter.stopAfterOnePass(True)
    featsNorm = [FU.normalize_pattern_maxenergy(p,8,True,False).flatten() for p in data_iter]
    featsNorm = np.array(featsNorm)
    res = [np.sum(r) > 0 for r in featsNorm]
    res2 = np.where(res)
    featsNorm = featsNorm[res2]
    print 'features from matfile (old school) computed, shape =',featsNorm.shape
    
    # compare
    min_len = min(mat_feats.shape[0],online_feats.shape[0],featsNorm.shape[0])
    if mat_feats.shape != online_feats.shape:
        print 'wrong shape between online and mat feats...'

    # plot matfile features
    P.figure()
    plotall([x.reshape(12,mat_feats.shape[1]/12) for x in mat_feats[:3]],
            interpolation='nearest',aspect='auto',cmap=P.cm.gray_r,